LCOV - code coverage report
Current view: top level - home/mbr/git/openssl.git/ssl - s3_srvr.c (source / functions) Hit Total Coverage
Test: lcov_coverage_final.info Lines: 840 1465 57.3 %
Date: 2014-08-02 Functions: 14 18 77.8 %
Branches: 435 941 46.2 %

           Branch data     Line data    Source code
       1                 :            : /* ssl/s3_srvr.c -*- mode:C; c-file-style: "eay" -*- */
       2                 :            : /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
       3                 :            :  * All rights reserved.
       4                 :            :  *
       5                 :            :  * This package is an SSL implementation written
       6                 :            :  * by Eric Young (eay@cryptsoft.com).
       7                 :            :  * The implementation was written so as to conform with Netscapes SSL.
       8                 :            :  * 
       9                 :            :  * This library is free for commercial and non-commercial use as long as
      10                 :            :  * the following conditions are aheared to.  The following conditions
      11                 :            :  * apply to all code found in this distribution, be it the RC4, RSA,
      12                 :            :  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
      13                 :            :  * included with this distribution is covered by the same copyright terms
      14                 :            :  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
      15                 :            :  * 
      16                 :            :  * Copyright remains Eric Young's, and as such any Copyright notices in
      17                 :            :  * the code are not to be removed.
      18                 :            :  * If this package is used in a product, Eric Young should be given attribution
      19                 :            :  * as the author of the parts of the library used.
      20                 :            :  * This can be in the form of a textual message at program startup or
      21                 :            :  * in documentation (online or textual) provided with the package.
      22                 :            :  * 
      23                 :            :  * Redistribution and use in source and binary forms, with or without
      24                 :            :  * modification, are permitted provided that the following conditions
      25                 :            :  * are met:
      26                 :            :  * 1. Redistributions of source code must retain the copyright
      27                 :            :  *    notice, this list of conditions and the following disclaimer.
      28                 :            :  * 2. Redistributions in binary form must reproduce the above copyright
      29                 :            :  *    notice, this list of conditions and the following disclaimer in the
      30                 :            :  *    documentation and/or other materials provided with the distribution.
      31                 :            :  * 3. All advertising materials mentioning features or use of this software
      32                 :            :  *    must display the following acknowledgement:
      33                 :            :  *    "This product includes cryptographic software written by
      34                 :            :  *     Eric Young (eay@cryptsoft.com)"
      35                 :            :  *    The word 'cryptographic' can be left out if the rouines from the library
      36                 :            :  *    being used are not cryptographic related :-).
      37                 :            :  * 4. If you include any Windows specific code (or a derivative thereof) from 
      38                 :            :  *    the apps directory (application code) you must include an acknowledgement:
      39                 :            :  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
      40                 :            :  * 
      41                 :            :  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
      42                 :            :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      43                 :            :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      44                 :            :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
      45                 :            :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      46                 :            :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      47                 :            :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      48                 :            :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      49                 :            :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      50                 :            :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      51                 :            :  * SUCH DAMAGE.
      52                 :            :  * 
      53                 :            :  * The licence and distribution terms for any publically available version or
      54                 :            :  * derivative of this code cannot be changed.  i.e. this code cannot simply be
      55                 :            :  * copied and put under another distribution licence
      56                 :            :  * [including the GNU Public Licence.]
      57                 :            :  */
      58                 :            : /* ====================================================================
      59                 :            :  * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
      60                 :            :  *
      61                 :            :  * Redistribution and use in source and binary forms, with or without
      62                 :            :  * modification, are permitted provided that the following conditions
      63                 :            :  * are met:
      64                 :            :  *
      65                 :            :  * 1. Redistributions of source code must retain the above copyright
      66                 :            :  *    notice, this list of conditions and the following disclaimer. 
      67                 :            :  *
      68                 :            :  * 2. Redistributions in binary form must reproduce the above copyright
      69                 :            :  *    notice, this list of conditions and the following disclaimer in
      70                 :            :  *    the documentation and/or other materials provided with the
      71                 :            :  *    distribution.
      72                 :            :  *
      73                 :            :  * 3. All advertising materials mentioning features or use of this
      74                 :            :  *    software must display the following acknowledgment:
      75                 :            :  *    "This product includes software developed by the OpenSSL Project
      76                 :            :  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
      77                 :            :  *
      78                 :            :  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
      79                 :            :  *    endorse or promote products derived from this software without
      80                 :            :  *    prior written permission. For written permission, please contact
      81                 :            :  *    openssl-core@openssl.org.
      82                 :            :  *
      83                 :            :  * 5. Products derived from this software may not be called "OpenSSL"
      84                 :            :  *    nor may "OpenSSL" appear in their names without prior written
      85                 :            :  *    permission of the OpenSSL Project.
      86                 :            :  *
      87                 :            :  * 6. Redistributions of any form whatsoever must retain the following
      88                 :            :  *    acknowledgment:
      89                 :            :  *    "This product includes software developed by the OpenSSL Project
      90                 :            :  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
      91                 :            :  *
      92                 :            :  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
      93                 :            :  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      94                 :            :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
      95                 :            :  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
      96                 :            :  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      97                 :            :  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
      98                 :            :  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
      99                 :            :  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     100                 :            :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     101                 :            :  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     102                 :            :  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
     103                 :            :  * OF THE POSSIBILITY OF SUCH DAMAGE.
     104                 :            :  * ====================================================================
     105                 :            :  *
     106                 :            :  * This product includes cryptographic software written by Eric Young
     107                 :            :  * (eay@cryptsoft.com).  This product includes software written by Tim
     108                 :            :  * Hudson (tjh@cryptsoft.com).
     109                 :            :  *
     110                 :            :  */
     111                 :            : /* ====================================================================
     112                 :            :  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
     113                 :            :  *
     114                 :            :  * Portions of the attached software ("Contribution") are developed by 
     115                 :            :  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
     116                 :            :  *
     117                 :            :  * The Contribution is licensed pursuant to the OpenSSL open source
     118                 :            :  * license provided above.
     119                 :            :  *
     120                 :            :  * ECC cipher suite support in OpenSSL originally written by
     121                 :            :  * Vipul Gupta and Sumit Gupta of Sun Microsystems Laboratories.
     122                 :            :  *
     123                 :            :  */
     124                 :            : /* ====================================================================
     125                 :            :  * Copyright 2005 Nokia. All rights reserved.
     126                 :            :  *
     127                 :            :  * The portions of the attached software ("Contribution") is developed by
     128                 :            :  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
     129                 :            :  * license.
     130                 :            :  *
     131                 :            :  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
     132                 :            :  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
     133                 :            :  * support (see RFC 4279) to OpenSSL.
     134                 :            :  *
     135                 :            :  * No patent licenses or other rights except those expressly stated in
     136                 :            :  * the OpenSSL open source license shall be deemed granted or received
     137                 :            :  * expressly, by implication, estoppel, or otherwise.
     138                 :            :  *
     139                 :            :  * No assurances are provided by Nokia that the Contribution does not
     140                 :            :  * infringe the patent or other intellectual property rights of any third
     141                 :            :  * party or that the license provides you with all the necessary rights
     142                 :            :  * to make use of the Contribution.
     143                 :            :  *
     144                 :            :  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
     145                 :            :  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
     146                 :            :  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
     147                 :            :  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
     148                 :            :  * OTHERWISE.
     149                 :            :  */
     150                 :            : 
     151                 :            : #define REUSE_CIPHER_BUG
     152                 :            : #define NETSCAPE_HANG_BUG
     153                 :            : 
     154                 :            : #include <stdio.h>
     155                 :            : #include "ssl_locl.h"
     156                 :            : #include "kssl_lcl.h"
     157                 :            : #include <openssl/buffer.h>
     158                 :            : #include <openssl/rand.h>
     159                 :            : #include <openssl/objects.h>
     160                 :            : #include <openssl/evp.h>
     161                 :            : #include <openssl/hmac.h>
     162                 :            : #include <openssl/x509.h>
     163                 :            : #ifndef OPENSSL_NO_DH
     164                 :            : #include <openssl/dh.h>
     165                 :            : #endif
     166                 :            : #include <openssl/bn.h>
     167                 :            : #ifndef OPENSSL_NO_KRB5
     168                 :            : #include <openssl/krb5_asn.h>
     169                 :            : #endif
     170                 :            : #include <openssl/md5.h>
     171                 :            : 
     172                 :            : static const SSL_METHOD *ssl3_get_server_method(int ver);
     173                 :            : 
     174                 :          0 : static const SSL_METHOD *ssl3_get_server_method(int ver)
     175                 :            :         {
     176         [ #  # ]:          0 :         if (ver == SSL3_VERSION)
     177                 :          0 :                 return(SSLv3_server_method());
     178                 :            :         else
     179                 :            :                 return(NULL);
     180                 :            :         }
     181                 :            : 
     182                 :            : #ifndef OPENSSL_NO_SRP
     183                 :       1080 : static int ssl_check_srp_ext_ClientHello(SSL *s, int *al)
     184                 :            :         {
     185                 :       1080 :         int ret = SSL_ERROR_NONE;
     186                 :            : 
     187                 :       1080 :         *al = SSL_AD_UNRECOGNIZED_NAME;
     188                 :            : 
     189 [ +  + ][ +  - ]:       1080 :         if ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) &&
     190                 :         22 :             (s->srp_ctx.TLS_ext_srp_username_callback != NULL))
     191                 :            :                 {
     192         [ -  + ]:         22 :                 if(s->srp_ctx.login == NULL)
     193                 :            :                         {
     194                 :            :                         /* RFC 5054 says SHOULD reject, 
     195                 :            :                            we do so if There is no srp login name */
     196                 :          0 :                         ret = SSL3_AL_FATAL;
     197                 :          0 :                         *al = SSL_AD_UNKNOWN_PSK_IDENTITY;
     198                 :            :                         }
     199                 :            :                 else
     200                 :            :                         {
     201                 :         22 :                         ret = SSL_srp_server_param_with_username(s,al);
     202                 :            :                         }
     203                 :            :                 }
     204                 :       1080 :         return ret;
     205                 :            :         }
     206                 :            : #endif
     207                 :            : 
     208                 :          0 : IMPLEMENT_ssl3_meth_func(SSLv3_server_method,
     209                 :            :                         ssl3_accept,
     210                 :            :                         ssl_undefined_function,
     211                 :            :                         ssl3_get_server_method)
     212                 :            : 
     213                 :      33851 : int ssl3_accept(SSL *s)
     214                 :            :         {
     215                 :            :         BUF_MEM *buf;
     216                 :      33851 :         unsigned long alg_k,Time=(unsigned long)time(NULL);
     217                 :      33851 :         void (*cb)(const SSL *ssl,int type,int val)=NULL;
     218                 :      33851 :         int ret= -1;
     219                 :      33851 :         int new_state,state,skip=0;
     220                 :            : 
     221                 :      33851 :         RAND_add(&Time,sizeof(Time),0);
     222                 :      33851 :         ERR_clear_error();
     223                 :      33851 :         clear_sys_error();
     224                 :            : 
     225         [ +  - ]:      33851 :         if (s->info_callback != NULL)
     226                 :            :                 cb=s->info_callback;
     227         [ -  + ]:      33851 :         else if (s->ctx->info_callback != NULL)
     228                 :          0 :                 cb=s->ctx->info_callback;
     229                 :            : 
     230                 :            :         /* init things to blank */
     231                 :      33851 :         s->in_handshake++;
     232 [ +  - ][ +  + ]:      33851 :         if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s);
     233                 :            : 
     234         [ -  + ]:      33851 :         if (s->cert == NULL)
     235                 :            :                 {
     236                 :          0 :                 SSLerr(SSL_F_SSL3_ACCEPT,SSL_R_NO_CERTIFICATE_SET);
     237                 :          0 :                 return(-1);
     238                 :            :                 }
     239                 :            : 
     240                 :            : #ifndef OPENSSL_NO_HEARTBEATS
     241                 :            :         /* If we're awaiting a HeartbeatResponse, pretend we
     242                 :            :          * already got and don't await it anymore, because
     243                 :            :          * Heartbeats don't make sense during handshakes anyway.
     244                 :            :          */
     245         [ -  + ]:      33851 :         if (s->tlsext_hb_pending)
     246                 :            :                 {
     247                 :          0 :                 s->tlsext_hb_pending = 0;
     248                 :      47161 :                 s->tlsext_hb_seq++;
     249                 :            :                 }
     250                 :            : #endif
     251                 :            : 
     252                 :            :         for (;;)
     253                 :            :                 {
     254                 :      50535 :                 state=s->state;
     255                 :            : 
     256   [ -  +  -  -  :      50535 :                 switch (s->state)
          +  -  +  +  +  
          +  +  +  +  +  
          +  +  +  +  -  
             +  +  +  - ]
     257                 :            :                         {
     258                 :            :                 case SSL_ST_RENEGOTIATE:
     259                 :          0 :                         s->renegotiate=1;
     260                 :            :                         /* s->state=SSL_ST_ACCEPT; */
     261                 :            : 
     262                 :            :                 case SSL_ST_BEFORE:
     263                 :            :                 case SSL_ST_ACCEPT:
     264                 :            :                 case SSL_ST_BEFORE|SSL_ST_ACCEPT:
     265                 :            :                 case SSL_ST_OK|SSL_ST_ACCEPT:
     266                 :            : 
     267                 :        880 :                         s->server=1;
     268         [ -  + ]:        880 :                         if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
     269                 :            : 
     270         [ -  + ]:        880 :                         if ((s->version>>8) != 3)
     271                 :            :                                 {
     272                 :          0 :                                 SSLerr(SSL_F_SSL3_ACCEPT, ERR_R_INTERNAL_ERROR);
     273                 :          0 :                                 return -1;
     274                 :            :                                 }
     275                 :            : 
     276         [ -  + ]:        880 :                         if (!ssl_security(s, SSL_SECOP_VERSION, 0,
     277                 :            :                                                         s->version, NULL))
     278                 :            :                                 {
     279                 :          0 :                                 SSLerr(SSL_F_SSL3_ACCEPT, SSL_R_VERSION_TOO_LOW);
     280                 :          0 :                                 return -1;
     281                 :            :                                 }
     282                 :            : 
     283                 :        880 :                         s->type=SSL_ST_ACCEPT;
     284                 :            : 
     285         [ +  - ]:        880 :                         if (s->init_buf == NULL)
     286                 :            :                                 {
     287         [ +  - ]:        880 :                                 if ((buf=BUF_MEM_new()) == NULL)
     288                 :            :                                         {
     289                 :            :                                         ret= -1;
     290                 :            :                                         goto end;
     291                 :            :                                         }
     292         [ +  - ]:        880 :                                 if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
     293                 :            :                                         {
     294                 :            :                                         ret= -1;
     295                 :            :                                         goto end;
     296                 :            :                                         }
     297                 :        880 :                                 s->init_buf=buf;
     298                 :            :                                 }
     299                 :            : 
     300         [ +  - ]:        880 :                         if (!ssl3_setup_buffers(s))
     301                 :            :                                 {
     302                 :            :                                 ret= -1;
     303                 :            :                                 goto end;
     304                 :            :                                 }
     305                 :            : 
     306                 :        880 :                         s->init_num=0;
     307                 :        880 :                         s->s3->flags &= ~SSL3_FLAGS_SGC_RESTART_DONE;
     308                 :        880 :                         s->s3->flags &= ~TLS1_FLAGS_SKIP_CERT_VERIFY;
     309                 :            : 
     310         [ +  - ]:        880 :                         if (s->state != SSL_ST_RENEGOTIATE)
     311                 :            :                                 {
     312                 :            :                                 /* Ok, we now need to push on a buffering BIO so that
     313                 :            :                                  * the output is sent in a way that TCP likes :-)
     314                 :            :                                  */
     315         [ +  - ]:        880 :                                 if (!ssl_init_wbio_buffer(s,1)) { ret= -1; goto end; }
     316                 :            :                                 
     317                 :        880 :                                 ssl3_init_finished_mac(s);
     318                 :        880 :                                 s->state=SSL3_ST_SR_CLNT_HELLO_A;
     319                 :        880 :                                 s->ctx->stats.sess_accept++;
     320                 :            :                                 }
     321 [ #  # ][ #  # ]:          0 :                         else if (!s->s3->send_connection_binding &&
     322                 :          0 :                                 !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION))
     323                 :            :                                 {
     324                 :            :                                 /* Server attempting to renegotiate with
     325                 :            :                                  * client that doesn't support secure
     326                 :            :                                  * renegotiation.
     327                 :            :                                  */
     328                 :          0 :                                 SSLerr(SSL_F_SSL3_ACCEPT, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
     329                 :          0 :                                 ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_HANDSHAKE_FAILURE);
     330                 :          0 :                                 ret = -1;
     331                 :          0 :                                 goto end;
     332                 :            :                                 }
     333                 :            :                         else
     334                 :            :                                 {
     335                 :            :                                 /* s->state == SSL_ST_RENEGOTIATE,
     336                 :            :                                  * we will just send a HelloRequest */
     337                 :          0 :                                 s->ctx->stats.sess_accept_renegotiate++;
     338                 :          0 :                                 s->state=SSL3_ST_SW_HELLO_REQ_A;
     339                 :            :                                 }
     340                 :            :                         break;
     341                 :            : 
     342                 :            :                 case SSL3_ST_SW_HELLO_REQ_A:
     343                 :            :                 case SSL3_ST_SW_HELLO_REQ_B:
     344                 :            : 
     345                 :          0 :                         s->shutdown=0;
     346                 :          0 :                         ret=ssl3_send_hello_request(s);
     347         [ #  # ]:          0 :                         if (ret <= 0) goto end;
     348                 :          0 :                         s->s3->tmp.next_state=SSL3_ST_SW_HELLO_REQ_C;
     349                 :          0 :                         s->state=SSL3_ST_SW_FLUSH;
     350                 :          0 :                         s->init_num=0;
     351                 :            : 
     352                 :          0 :                         ssl3_init_finished_mac(s);
     353                 :          0 :                         break;
     354                 :            : 
     355                 :            :                 case SSL3_ST_SW_HELLO_REQ_C:
     356                 :          0 :                         s->state=SSL_ST_OK;
     357                 :          0 :                         break;
     358                 :            : 
     359                 :            :                 case SSL3_ST_SR_CLNT_HELLO_A:
     360                 :            :                 case SSL3_ST_SR_CLNT_HELLO_B:
     361                 :            :                 case SSL3_ST_SR_CLNT_HELLO_C:
     362                 :            : 
     363                 :       7614 :                         ret=ssl3_get_client_hello(s);
     364         [ +  + ]:       7614 :                         if (ret <= 0) goto end;
     365                 :            : #ifndef OPENSSL_NO_SRP
     366                 :       1080 :                         s->state = SSL3_ST_SR_CLNT_HELLO_D;
     367                 :            :                 case SSL3_ST_SR_CLNT_HELLO_D:
     368                 :            :                         {
     369                 :            :                         int al;
     370         [ -  + ]:       1080 :                         if ((ret = ssl_check_srp_ext_ClientHello(s,&al))  < 0)
     371                 :            :                                         {
     372                 :            :                                         /* callback indicates firther work to be done */
     373                 :          0 :                                         s->rwstate=SSL_X509_LOOKUP;
     374                 :          0 :                                         goto end;
     375                 :            :                                         }
     376         [ -  + ]:       1080 :                         if (ret != SSL_ERROR_NONE)
     377                 :            :                                 {
     378                 :          0 :                                 ssl3_send_alert(s,SSL3_AL_FATAL,al);    
     379                 :            :                                 /* This is not really an error but the only means to
     380                 :            :                                    for a client to detect whether srp is supported. */
     381         [ #  # ]:          0 :                                    if (al != TLS1_AD_UNKNOWN_PSK_IDENTITY)      
     382                 :          0 :                                         SSLerr(SSL_F_SSL3_ACCEPT,SSL_R_CLIENTHELLO_TLSEXT);                     
     383                 :            :                                 ret = SSL_TLSEXT_ERR_ALERT_FATAL;                       
     384                 :            :                                 ret= -1;
     385                 :            :                                 goto end;       
     386                 :            :                                 }
     387                 :            :                         }
     388                 :            : #endif          
     389                 :            :                         
     390                 :       1080 :                         s->renegotiate = 2;
     391                 :       1080 :                         s->state=SSL3_ST_SW_SRVR_HELLO_A;
     392                 :       1080 :                         s->init_num=0;
     393                 :       1080 :                         break;
     394                 :            : 
     395                 :            :                 case SSL3_ST_SW_SRVR_HELLO_A:
     396                 :            :                 case SSL3_ST_SW_SRVR_HELLO_B:
     397                 :       1080 :                         ret=ssl3_send_server_hello(s);
     398         [ +  - ]:       1080 :                         if (ret <= 0) goto end;
     399                 :            : #ifndef OPENSSL_NO_TLSEXT
     400         [ +  + ]:       1080 :                         if (s->hit)
     401                 :            :                                 {
     402         [ -  + ]:         11 :                                 if (s->tlsext_ticket_expected)
     403                 :          0 :                                         s->state=SSL3_ST_SW_SESSION_TICKET_A;
     404                 :            :                                 else
     405                 :         11 :                                         s->state=SSL3_ST_SW_CHANGE_A;
     406                 :            :                                 }
     407                 :            : #else
     408                 :            :                         if (s->hit)
     409                 :            :                                         s->state=SSL3_ST_SW_CHANGE_A;
     410                 :            : #endif
     411                 :            :                         else
     412                 :       1069 :                                         s->state = SSL3_ST_SW_CERT_A;
     413                 :       1080 :                         s->init_num = 0;
     414                 :       1080 :                         break;
     415                 :            : 
     416                 :            :                 case SSL3_ST_SW_CERT_A:
     417                 :            :                 case SSL3_ST_SW_CERT_B:
     418                 :            :                         /* Check if it is anon DH or anon ECDH, */
     419                 :            :                         /* normal PSK or KRB5 or SRP */
     420         [ +  + ]:       1069 :                         if (!(s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL)
     421         [ +  + ]:        959 :                                 && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)
     422         [ +  - ]:        937 :                                 && !(s->s3->tmp.new_cipher->algorithm_auth & SSL_aKRB5))
     423                 :            :                                 {
     424                 :        937 :                                 ret=ssl3_send_server_certificate(s);
     425         [ +  - ]:        937 :                                 if (ret <= 0) goto end;
     426                 :            : #ifndef OPENSSL_NO_TLSEXT
     427         [ -  + ]:        937 :                                 if (s->tlsext_status_expected)
     428                 :          0 :                                         s->state=SSL3_ST_SW_CERT_STATUS_A;
     429                 :            :                                 else
     430                 :        937 :                                         s->state=SSL3_ST_SW_KEY_EXCH_A;
     431                 :            :                                 }
     432                 :            :                         else
     433                 :            :                                 {
     434                 :        132 :                                 skip = 1;
     435                 :        132 :                                 s->state=SSL3_ST_SW_KEY_EXCH_A;
     436                 :            :                                 }
     437                 :            : #else
     438                 :            :                                 }
     439                 :            :                         else
     440                 :            :                                 skip=1;
     441                 :            : 
     442                 :            :                         s->state=SSL3_ST_SW_KEY_EXCH_A;
     443                 :            : #endif
     444                 :       1069 :                         s->init_num=0;
     445                 :       1069 :                         break;
     446                 :            : 
     447                 :            :                 case SSL3_ST_SW_KEY_EXCH_A:
     448                 :            :                 case SSL3_ST_SW_KEY_EXCH_B:
     449                 :       1069 :                         alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
     450                 :            : 
     451                 :            :                         /* clear this, it may get reset by
     452                 :            :                          * send_server_key_exchange */
     453         [ -  + ]:       1069 :                         if ((s->options & SSL_OP_EPHEMERAL_RSA)
     454                 :            : #ifndef OPENSSL_NO_KRB5
     455                 :            :                                 && !(alg_k & SSL_kKRB5)
     456                 :            : #endif /* OPENSSL_NO_KRB5 */
     457                 :            :                                 )
     458                 :            :                                 /* option SSL_OP_EPHEMERAL_RSA sends temporary RSA key
     459                 :            :                                  * even when forbidden by protocol specs
     460                 :            :                                  * (handshake may fail as clients are not required to
     461                 :            :                                  * be able to handle this) */
     462                 :          0 :                                 s->s3->tmp.use_rsa_tmp=1;
     463                 :            :                         else
     464                 :       1069 :                                 s->s3->tmp.use_rsa_tmp=0;
     465                 :            : 
     466                 :            : 
     467                 :            :                         /* only send if a DH key exchange, fortezza or
     468                 :            :                          * RSA but we have a sign only certificate
     469                 :            :                          *
     470                 :            :                          * PSK: may send PSK identity hints
     471                 :            :                          *
     472                 :            :                          * For ECC ciphersuites, we send a serverKeyExchange
     473                 :            :                          * message only if the cipher suite is either
     474                 :            :                          * ECDH-anon or ECDHE. In other cases, the
     475                 :            :                          * server certificate contains the server's
     476                 :            :                          * public key for key exchange.
     477                 :            :                          */
     478         [ +  - ]:       1069 :                         if (s->s3->tmp.use_rsa_tmp
     479                 :            :                         /* PSK: send ServerKeyExchange if PSK identity
     480                 :            :                          * hint if provided */
     481                 :            : #ifndef OPENSSL_NO_PSK
     482 [ +  + ][ -  + ]:       1069 :                             || ((alg_k & SSL_kPSK) && s->ctx->psk_identity_hint)
     483                 :            : #endif
     484                 :            : #ifndef OPENSSL_NO_SRP
     485                 :            :                             /* SRP: send ServerKeyExchange */
     486                 :            :                             || (alg_k & SSL_kSRP)
     487                 :            : #endif
     488                 :            :                             || (alg_k & SSL_kDHE)
     489         [ +  + ]:       1047 :                             || (alg_k & SSL_kECDHE)
     490         [ +  - ]:        365 :                             || ((alg_k & SSL_kRSA)
     491         [ +  - ]:        365 :                                 && (s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL
     492         [ +  + ]:        365 :                                     || (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher)
     493 [ -  + ][ +  - ]:         33 :                                         && EVP_PKEY_size(s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey)*8 > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)
     494                 :            :                                         )
     495                 :            :                                     )
     496                 :            :                                 )
     497                 :            :                             )
     498                 :            :                                 {
     499                 :        737 :                                 ret=ssl3_send_server_key_exchange(s);
     500         [ +  - ]:        737 :                                 if (ret <= 0) goto end;
     501                 :            :                                 }
     502                 :            :                         else
     503                 :            :                                 skip=1;
     504                 :            : 
     505                 :       1069 :                         s->state=SSL3_ST_SW_CERT_REQ_A;
     506                 :       1069 :                         s->init_num=0;
     507                 :       1069 :                         break;
     508                 :            : 
     509                 :            :                 case SSL3_ST_SW_CERT_REQ_A:
     510                 :            :                 case SSL3_ST_SW_CERT_REQ_B:
     511         [ +  + ]:       1069 :                         if (/* don't request cert unless asked for it: */
     512         [ -  + ]:         99 :                                 !(s->verify_mode & SSL_VERIFY_PEER) ||
     513                 :            :                                 /* if SSL_VERIFY_CLIENT_ONCE is set,
     514                 :            :                                  * don't request cert during re-negotiation: */
     515         [ #  # ]:          0 :                                 ((s->session->peer != NULL) &&
     516         [ -  + ]:         99 :                                  (s->verify_mode & SSL_VERIFY_CLIENT_ONCE)) ||
     517                 :            :                                 /* never request cert in anonymous ciphersuites
     518                 :            :                                  * (see section "Certificate request" in SSL 3 drafts
     519                 :            :                                  * and in RFC 2246): */
     520         [ #  # ]:          0 :                                 ((s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL) &&
     521                 :            :                                  /* ... except when the application insists on verification
     522                 :            :                                   * (against the specs, but s3_clnt.c accepts this for SSL 3) */
     523         [ +  - ]:         99 :                                  !(s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) ||
     524                 :            :                                  /* never request cert in Kerberos ciphersuites */
     525                 :         99 :                                 (s->s3->tmp.new_cipher->algorithm_auth & SSL_aKRB5)
     526                 :            :                                 /* With normal PSK Certificates and
     527                 :            :                                  * Certificate Requests are omitted */
     528         [ -  + ]:         99 :                                 || (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK))
     529                 :            :                                 {
     530                 :            :                                 /* no cert request */
     531                 :        970 :                                 skip=1;
     532                 :        970 :                                 s->s3->tmp.cert_request=0;
     533                 :        970 :                                 s->state=SSL3_ST_SW_SRVR_DONE_A;
     534         [ -  + ]:        970 :                                 if (s->s3->handshake_buffer)
     535         [ #  # ]:          0 :                                         if (!ssl3_digest_cached_records(s))
     536                 :            :                                                 return -1;
     537                 :            :                                 }
     538                 :            :                         else
     539                 :            :                                 {
     540                 :         99 :                                 s->s3->tmp.cert_request=1;
     541                 :         99 :                                 ret=ssl3_send_certificate_request(s);
     542         [ +  - ]:         99 :                                 if (ret <= 0) goto end;
     543                 :            : #ifndef NETSCAPE_HANG_BUG
     544                 :            :                                 s->state=SSL3_ST_SW_SRVR_DONE_A;
     545                 :            : #else
     546                 :         99 :                                 s->state=SSL3_ST_SW_FLUSH;
     547                 :         99 :                                 s->s3->tmp.next_state=SSL3_ST_SR_CERT_A;
     548                 :            : #endif
     549                 :         99 :                                 s->init_num=0;
     550                 :            :                                 }
     551                 :            :                         break;
     552                 :            : 
     553                 :            :                 case SSL3_ST_SW_SRVR_DONE_A:
     554                 :            :                 case SSL3_ST_SW_SRVR_DONE_B:
     555                 :        970 :                         ret=ssl3_send_server_done(s);
     556         [ +  - ]:        970 :                         if (ret <= 0) goto end;
     557                 :        970 :                         s->s3->tmp.next_state=SSL3_ST_SR_CERT_A;
     558                 :        970 :                         s->state=SSL3_ST_SW_FLUSH;
     559                 :        970 :                         s->init_num=0;
     560                 :        970 :                         break;
     561                 :            :                 
     562                 :            :                 case SSL3_ST_SW_FLUSH:
     563                 :            : 
     564                 :            :                         /* This code originally checked to see if
     565                 :            :                          * any data was pending using BIO_CTRL_INFO
     566                 :            :                          * and then flushed. This caused problems
     567                 :            :                          * as documented in PR#1939. The proposed
     568                 :            :                          * fix doesn't completely resolve this issue
     569                 :            :                          * as buggy implementations of BIO_CTRL_PENDING
     570                 :            :                          * still exist. So instead we just flush
     571                 :            :                          * unconditionally.
     572                 :            :                          */
     573                 :            : 
     574                 :       8439 :                         s->rwstate=SSL_WRITING;
     575         [ +  + ]:       8439 :                         if (BIO_flush(s->wbio) <= 0)
     576                 :            :                                 {
     577                 :            :                                 ret= -1;
     578                 :            :                                 goto end;
     579                 :            :                                 }
     580                 :       2149 :                         s->rwstate=SSL_NOTHING;
     581                 :            : 
     582                 :       2149 :                         s->state=s->s3->tmp.next_state;
     583                 :       2149 :                         break;
     584                 :            : 
     585                 :            :                 case SSL3_ST_SR_CERT_A:
     586                 :            :                 case SSL3_ST_SR_CERT_B:
     587                 :            :                         /* Check for second client hello (MS SGC) */
     588                 :       9664 :                         ret = ssl3_check_client_hello(s);
     589         [ +  + ]:       9664 :                         if (ret <= 0)
     590                 :            :                                 goto end;
     591         [ -  + ]:       1069 :                         if (ret == 2)
     592                 :          0 :                                 s->state = SSL3_ST_SR_CLNT_HELLO_C;
     593                 :            :                         else {
     594         [ +  + ]:       1069 :                                 if (s->s3->tmp.cert_request)
     595                 :            :                                         {
     596                 :         99 :                                         ret=ssl3_get_client_certificate(s);
     597         [ +  - ]:         99 :                                         if (ret <= 0) goto end;
     598                 :            :                                         }
     599                 :       1069 :                                 s->init_num=0;
     600                 :       1069 :                                 s->state=SSL3_ST_SR_KEY_EXCH_A;
     601                 :            :                         }
     602                 :            :                         break;
     603                 :            : 
     604                 :            :                 case SSL3_ST_SR_KEY_EXCH_A:
     605                 :            :                 case SSL3_ST_SR_KEY_EXCH_B:
     606                 :       1509 :                         ret=ssl3_get_client_key_exchange(s);
     607         [ +  + ]:       1509 :                         if (ret <= 0)
     608                 :            :                                 goto end;
     609         [ -  + ]:       1069 :                         if (ret == 2)
     610                 :            :                                 {
     611                 :            :                                 /* For the ECDH ciphersuites when
     612                 :            :                                  * the client sends its ECDH pub key in
     613                 :            :                                  * a certificate, the CertificateVerify
     614                 :            :                                  * message is not sent.
     615                 :            :                                  * Also for GOST ciphersuites when
     616                 :            :                                  * the client uses its key from the certificate
     617                 :            :                                  * for key exchange.
     618                 :            :                                  */
     619                 :            : #if defined(OPENSSL_NO_TLSEXT) || defined(OPENSSL_NO_NEXTPROTONEG)
     620                 :            :                                 s->state=SSL3_ST_SR_FINISHED_A;
     621                 :            : #else
     622         [ #  # ]:          0 :                                 if (s->s3->next_proto_neg_seen)
     623                 :          0 :                                         s->state=SSL3_ST_SR_NEXT_PROTO_A;
     624                 :            :                                 else
     625                 :          0 :                                         s->state=SSL3_ST_SR_FINISHED_A;
     626                 :            : #endif
     627                 :          0 :                                 s->init_num = 0;
     628                 :            :                                 }
     629         [ +  + ]:       1069 :                         else if (SSL_USE_SIGALGS(s))
     630                 :            :                                 {
     631                 :        200 :                                 s->state=SSL3_ST_SR_CERT_VRFY_A;
     632                 :        200 :                                 s->init_num=0;
     633         [ +  + ]:        200 :                                 if (!s->session->peer)
     634                 :            :                                         break;
     635                 :            :                                 /* For sigalgs freeze the handshake buffer
     636                 :            :                                  * at this point and digest cached records.
     637                 :            :                                  */
     638         [ -  + ]:         55 :                                 if (!s->s3->handshake_buffer)
     639                 :            :                                         {
     640                 :          0 :                                         SSLerr(SSL_F_SSL3_ACCEPT,ERR_R_INTERNAL_ERROR);
     641                 :          0 :                                         return -1;
     642                 :            :                                         }
     643                 :         55 :                                 s->s3->flags |= TLS1_FLAGS_KEEP_HANDSHAKE;
     644         [ +  - ]:         55 :                                 if (!ssl3_digest_cached_records(s))
     645                 :            :                                         return -1;
     646                 :            :                                 }
     647                 :            :                         else
     648                 :            :                                 {
     649                 :        869 :                                 int offset=0;
     650                 :            :                                 int dgst_num;
     651                 :            : 
     652                 :        869 :                                 s->state=SSL3_ST_SR_CERT_VRFY_A;
     653                 :        869 :                                 s->init_num=0;
     654                 :            : 
     655                 :            :                                 /* We need to get hashes here so if there is
     656                 :            :                                  * a client cert, it can be verified
     657                 :            :                                  * FIXME - digest processing for CertificateVerify
     658                 :            :                                  * should be generalized. But it is next step
     659                 :            :                                  */
     660         [ -  + ]:        869 :                                 if (s->s3->handshake_buffer)
     661         [ #  # ]:        869 :                                         if (!ssl3_digest_cached_records(s))
     662                 :            :                                                 return -1;
     663         [ +  + ]:       6083 :                                 for (dgst_num=0; dgst_num<SSL_MAX_DIGEST;dgst_num++) 
     664         [ +  + ]:       5214 :                                         if (s->s3->handshake_dgst[dgst_num]) 
     665                 :            :                                                 {
     666                 :            :                                                 int dgst_size;
     667                 :            : 
     668                 :       1738 :                                                 s->method->ssl3_enc->cert_verify_mac(s,EVP_MD_CTX_type(s->s3->handshake_dgst[dgst_num]),&(s->s3->tmp.cert_verify_md[offset]));
     669                 :       1738 :                                                 dgst_size=EVP_MD_CTX_size(s->s3->handshake_dgst[dgst_num]);
     670         [ +  - ]:       1738 :                                                 if (dgst_size < 0)
     671                 :            :                                                         {
     672                 :            :                                                         ret = -1;
     673                 :            :                                                         goto end;
     674                 :            :                                                         }
     675                 :       1738 :                                                 offset+=dgst_size;
     676                 :            :                                                 }               
     677                 :            :                                 }
     678                 :            :                         break;
     679                 :            : 
     680                 :            :                 case SSL3_ST_SR_CERT_VRFY_A:
     681                 :            :                 case SSL3_ST_SR_CERT_VRFY_B:
     682                 :            : 
     683                 :      10595 :                         s->s3->flags |= SSL3_FLAGS_CCS_OK;
     684                 :            :                         /* we should decide if we expected this one */
     685                 :      10595 :                         ret=ssl3_get_cert_verify(s);
     686         [ +  + ]:      10595 :                         if (ret <= 0) goto end;
     687                 :            : 
     688                 :            : #if defined(OPENSSL_NO_TLSEXT) || defined(OPENSSL_NO_NEXTPROTONEG)
     689                 :            :                         s->state=SSL3_ST_SR_FINISHED_A;
     690                 :            : #else
     691         [ +  + ]:       1069 :                         if (s->s3->next_proto_neg_seen)
     692                 :         44 :                                 s->state=SSL3_ST_SR_NEXT_PROTO_A;
     693                 :            :                         else
     694                 :       1025 :                                 s->state=SSL3_ST_SR_FINISHED_A;
     695                 :            : #endif
     696                 :       1069 :                         s->init_num=0;
     697                 :       1069 :                         break;
     698                 :            : 
     699                 :            : #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
     700                 :            :                 case SSL3_ST_SR_NEXT_PROTO_A:
     701                 :            :                 case SSL3_ST_SR_NEXT_PROTO_B:
     702                 :        231 :                         ret=ssl3_get_next_proto(s);
     703         [ +  + ]:        231 :                         if (ret <= 0) goto end;
     704                 :         55 :                         s->init_num = 0;
     705                 :         55 :                         s->state=SSL3_ST_SR_FINISHED_A;
     706                 :         55 :                         break;
     707                 :            : #endif
     708                 :            : 
     709                 :            :                 case SSL3_ST_SR_FINISHED_A:
     710                 :            :                 case SSL3_ST_SR_FINISHED_B:
     711                 :       2290 :                         s->s3->flags |= SSL3_FLAGS_CCS_OK;
     712                 :       2290 :                         ret=ssl3_get_finished(s,SSL3_ST_SR_FINISHED_A,
     713                 :            :                                 SSL3_ST_SR_FINISHED_B);
     714         [ +  + ]:       2290 :                         if (ret <= 0) goto end;
     715         [ +  + ]:       1080 :                         if (s->hit)
     716                 :         11 :                                 s->state=SSL_ST_OK;
     717                 :            : #ifndef OPENSSL_NO_TLSEXT
     718         [ +  + ]:       1069 :                         else if (s->tlsext_ticket_expected)
     719                 :        816 :                                 s->state=SSL3_ST_SW_SESSION_TICKET_A;
     720                 :            : #endif
     721                 :            :                         else
     722                 :        253 :                                 s->state=SSL3_ST_SW_CHANGE_A;
     723                 :       1080 :                         s->init_num=0;
     724                 :       1080 :                         break;
     725                 :            : 
     726                 :            : #ifndef OPENSSL_NO_TLSEXT
     727                 :            :                 case SSL3_ST_SW_SESSION_TICKET_A:
     728                 :            :                 case SSL3_ST_SW_SESSION_TICKET_B:
     729                 :        816 :                         ret=ssl3_send_newsession_ticket(s);
     730         [ +  - ]:        816 :                         if (ret <= 0) goto end;
     731                 :        816 :                         s->state=SSL3_ST_SW_CHANGE_A;
     732                 :        816 :                         s->init_num=0;
     733                 :        816 :                         break;
     734                 :            : 
     735                 :            :                 case SSL3_ST_SW_CERT_STATUS_A:
     736                 :            :                 case SSL3_ST_SW_CERT_STATUS_B:
     737                 :          0 :                         ret=ssl3_send_cert_status(s);
     738         [ #  # ]:          0 :                         if (ret <= 0) goto end;
     739                 :          0 :                         s->state=SSL3_ST_SW_KEY_EXCH_A;
     740                 :          0 :                         s->init_num=0;
     741                 :          0 :                         break;
     742                 :            : 
     743                 :            : #endif
     744                 :            : 
     745                 :            :                 case SSL3_ST_SW_CHANGE_A:
     746                 :            :                 case SSL3_ST_SW_CHANGE_B:
     747                 :            : 
     748                 :       1080 :                         s->session->cipher=s->s3->tmp.new_cipher;
     749         [ +  - ]:       1080 :                         if (!s->method->ssl3_enc->setup_key_block(s))
     750                 :            :                                 { ret= -1; goto end; }
     751                 :            : 
     752                 :       1080 :                         ret=ssl3_send_change_cipher_spec(s,
     753                 :            :                                 SSL3_ST_SW_CHANGE_A,SSL3_ST_SW_CHANGE_B);
     754                 :            : 
     755         [ +  - ]:       1080 :                         if (ret <= 0) goto end;
     756                 :       1080 :                         s->state=SSL3_ST_SW_FINISHED_A;
     757                 :       1080 :                         s->init_num=0;
     758                 :            : 
     759         [ +  - ]:       1080 :                         if (!s->method->ssl3_enc->change_cipher_state(s,
     760                 :            :                                 SSL3_CHANGE_CIPHER_SERVER_WRITE))
     761                 :            :                                 {
     762                 :            :                                 ret= -1;
     763                 :            :                                 goto end;
     764                 :            :                                 }
     765                 :            : 
     766                 :            :                         break;
     767                 :            : 
     768                 :            :                 case SSL3_ST_SW_FINISHED_A:
     769                 :            :                 case SSL3_ST_SW_FINISHED_B:
     770                 :       1080 :                         ret=ssl3_send_finished(s,
     771                 :            :                                 SSL3_ST_SW_FINISHED_A,SSL3_ST_SW_FINISHED_B,
     772                 :            :                                 s->method->ssl3_enc->server_finished_label,
     773                 :       1080 :                                 s->method->ssl3_enc->server_finished_label_len);
     774         [ +  - ]:       1080 :                         if (ret <= 0) goto end;
     775                 :       1080 :                         s->state=SSL3_ST_SW_FLUSH;
     776         [ +  + ]:       1080 :                         if (s->hit)
     777                 :            :                                 {
     778                 :            : #if defined(OPENSSL_NO_TLSEXT) || defined(OPENSSL_NO_NEXTPROTONEG)
     779                 :            :                                 s->s3->tmp.next_state=SSL3_ST_SR_FINISHED_A;
     780                 :            : #else
     781         [ +  - ]:         11 :                                 if (s->s3->next_proto_neg_seen)
     782                 :            :                                         {
     783                 :         11 :                                         s->s3->flags |= SSL3_FLAGS_CCS_OK;
     784                 :         11 :                                         s->s3->tmp.next_state=SSL3_ST_SR_NEXT_PROTO_A;
     785                 :            :                                         }
     786                 :            :                                 else
     787                 :          0 :                                         s->s3->tmp.next_state=SSL3_ST_SR_FINISHED_A;
     788                 :            : #endif
     789                 :            :                                 }
     790                 :            :                         else
     791                 :       1069 :                                 s->s3->tmp.next_state=SSL_ST_OK;
     792                 :       1080 :                         s->init_num=0;
     793                 :       1080 :                         break;
     794                 :            : 
     795                 :            :                 case SSL_ST_OK:
     796                 :            :                         /* clean a few things up */
     797                 :       1080 :                         ssl3_cleanup_key_block(s);
     798                 :            : 
     799                 :       1080 :                         BUF_MEM_free(s->init_buf);
     800                 :       1080 :                         s->init_buf=NULL;
     801                 :            : 
     802                 :            :                         /* remove buffering on output */
     803                 :       1080 :                         ssl_free_wbio_buffer(s);
     804                 :            : 
     805                 :       1080 :                         s->init_num=0;
     806                 :            : 
     807         [ +  - ]:       1080 :                         if (s->renegotiate == 2) /* skipped if we just sent a HelloRequest */
     808                 :            :                                 {
     809                 :       1080 :                                 s->renegotiate=0;
     810                 :       1080 :                                 s->new_session=0;
     811                 :            :                                 
     812                 :       1080 :                                 ssl_update_cache(s,SSL_SESS_CACHE_SERVER);
     813                 :            :                                 
     814                 :       1080 :                                 s->ctx->stats.sess_accept_good++;
     815                 :            :                                 /* s->server=1; */
     816                 :       1080 :                                 s->handshake_func=ssl3_accept;
     817                 :            : 
     818         [ -  + ]:       1080 :                                 if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);
     819                 :            :                                 }
     820                 :            :                         
     821                 :            :                         ret = 1;
     822                 :            :                         goto end;
     823                 :            :                         /* break; */
     824                 :            : 
     825                 :            :                 default:
     826                 :          0 :                         SSLerr(SSL_F_SSL3_ACCEPT,SSL_R_UNKNOWN_STATE);
     827                 :          0 :                         ret= -1;
     828                 :          0 :                         goto end;
     829                 :            :                         /* break; */
     830                 :            :                         }
     831                 :            :                 
     832         [ +  + ]:      16684 :                 if (!s->s3->tmp.reuse_message && !skip)
     833                 :            :                         {
     834         [ -  + ]:      13310 :                         if (s->debug)
     835                 :            :                                 {
     836         [ #  # ]:          0 :                                 if ((ret=BIO_flush(s->wbio)) <= 0)
     837                 :            :                                         goto end;
     838                 :            :                                 }
     839                 :            : 
     840                 :            : 
     841 [ +  - ][ #  # ]:      13310 :                         if ((cb != NULL) && (s->state != state))
     842                 :            :                                 {
     843                 :          0 :                                 new_state=s->state;
     844                 :          0 :                                 s->state=state;
     845                 :          0 :                                 cb(s,SSL_CB_ACCEPT_LOOP,1);
     846                 :          0 :                                 s->state=new_state;
     847                 :            :                                 }
     848                 :            :                         }
     849                 :            :                 skip=0;
     850                 :            :                 }
     851                 :            : end:
     852                 :            :         /* BIO_flush(s->wbio); */
     853                 :            : 
     854                 :      33851 :         s->in_handshake--;
     855         [ -  + ]:      33851 :         if (cb != NULL)
     856                 :          0 :                 cb(s,SSL_CB_ACCEPT_EXIT,ret);
     857                 :      33851 :         return(ret);
     858                 :            :         }
     859                 :            : 
     860                 :          0 : int ssl3_send_hello_request(SSL *s)
     861                 :            :         {
     862                 :            : 
     863         [ #  # ]:          0 :         if (s->state == SSL3_ST_SW_HELLO_REQ_A)
     864                 :            :                 {
     865                 :          0 :                 ssl_set_handshake_header(s, SSL3_MT_HELLO_REQUEST, 0);
     866                 :          0 :                 s->state=SSL3_ST_SW_HELLO_REQ_B;
     867                 :            :                 }
     868                 :            : 
     869                 :            :         /* SSL3_ST_SW_HELLO_REQ_B */
     870                 :          0 :         return ssl_do_write(s);
     871                 :            :         }
     872                 :            : 
     873                 :       9664 : int ssl3_check_client_hello(SSL *s)
     874                 :            :         {
     875                 :            :         int ok;
     876                 :            :         long n;
     877                 :            : 
     878                 :            :         /* this function is called when we really expect a Certificate message,
     879                 :            :          * so permit appropriate message length */
     880                 :       9664 :         n=s->method->ssl_get_message(s,
     881                 :            :                 SSL3_ST_SR_CERT_A,
     882                 :            :                 SSL3_ST_SR_CERT_B,
     883                 :            :                 -1,
     884                 :            :                 s->max_cert_list,
     885                 :            :                 &ok);
     886         [ +  + ]:       9664 :         if (!ok) return((int)n);
     887                 :       1069 :         s->s3->tmp.reuse_message = 1;
     888         [ -  + ]:       1069 :         if (s->s3->tmp.message_type == SSL3_MT_CLIENT_HELLO)
     889                 :            :                 {
     890                 :            :                 /* We only allow the client to restart the handshake once per
     891                 :            :                  * negotiation. */
     892         [ #  # ]:          0 :                 if (s->s3->flags & SSL3_FLAGS_SGC_RESTART_DONE)
     893                 :            :                         {
     894                 :          0 :                         SSLerr(SSL_F_SSL3_CHECK_CLIENT_HELLO, SSL_R_MULTIPLE_SGC_RESTARTS);
     895                 :          0 :                         return -1;
     896                 :            :                         }
     897                 :            :                 /* Throw away what we have done so far in the current handshake,
     898                 :            :                  * which will now be aborted. (A full SSL_clear would be too much.) */
     899                 :            : #ifndef OPENSSL_NO_DH
     900         [ #  # ]:          0 :                 if (s->s3->tmp.dh != NULL)
     901                 :            :                         {
     902                 :          0 :                         DH_free(s->s3->tmp.dh);
     903                 :          0 :                         s->s3->tmp.dh = NULL;
     904                 :            :                         }
     905                 :            : #endif
     906                 :            : #ifndef OPENSSL_NO_ECDH
     907         [ #  # ]:          0 :                 if (s->s3->tmp.ecdh != NULL)
     908                 :            :                         {
     909                 :          0 :                         EC_KEY_free(s->s3->tmp.ecdh);
     910                 :          0 :                         s->s3->tmp.ecdh = NULL;
     911                 :            :                         }
     912                 :            : #endif
     913                 :          0 :                 s->s3->flags |= SSL3_FLAGS_SGC_RESTART_DONE;
     914                 :          0 :                 return 2;
     915                 :            :                 }
     916                 :            :         return 1;
     917                 :            : }
     918                 :            : 
     919                 :       7614 : int ssl3_get_client_hello(SSL *s)
     920                 :            :         {
     921                 :       7614 :         int i,j,ok,al=SSL_AD_INTERNAL_ERROR,ret= -1;
     922                 :            :         unsigned int cookie_len;
     923                 :            :         long n;
     924                 :            :         unsigned long id;
     925                 :            :         unsigned char *p,*d;
     926                 :            :         SSL_CIPHER *c;
     927                 :            : #ifndef OPENSSL_NO_COMP
     928                 :            :         unsigned char *q;
     929                 :       7614 :         SSL_COMP *comp=NULL;
     930                 :            : #endif
     931                 :       7614 :         STACK_OF(SSL_CIPHER) *ciphers=NULL;
     932                 :            : 
     933 [ -  + ][ #  # ]:       7614 :         if (s->state == SSL3_ST_SR_CLNT_HELLO_C && !s->first_packet)
     934                 :            :                 goto retry_cert;
     935                 :            : 
     936                 :            :         /* We do this so that we will respond with our native type.
     937                 :            :          * If we are TLSv1 and we get SSLv3, we will respond with TLSv1,
     938                 :            :          * This down switching should be handled by a different method.
     939                 :            :          * If we are SSLv3, we will respond with SSLv3, even if prompted with
     940                 :            :          * TLSv1.
     941                 :            :          */
     942         [ +  + ]:       7614 :         if (s->state == SSL3_ST_SR_CLNT_HELLO_A
     943                 :            :                 )
     944                 :            :                 {
     945                 :       1080 :                 s->state=SSL3_ST_SR_CLNT_HELLO_B;
     946                 :            :                 }
     947                 :       7614 :         s->first_packet=1;
     948                 :       7614 :         n=s->method->ssl_get_message(s,
     949                 :            :                 SSL3_ST_SR_CLNT_HELLO_B,
     950                 :            :                 SSL3_ST_SR_CLNT_HELLO_C,
     951                 :            :                 SSL3_MT_CLIENT_HELLO,
     952                 :            :                 SSL3_RT_MAX_PLAIN_LENGTH,
     953                 :            :                 &ok);
     954                 :            : 
     955         [ +  + ]:       7614 :         if (!ok) return((int)n);
     956                 :       1080 :         s->first_packet=0;
     957                 :       1080 :         d=p=(unsigned char *)s->init_msg;
     958                 :            : 
     959                 :            :         /* use version from inside client hello, not from record header
     960                 :            :          * (may differ: see RFC 2246, Appendix E, second paragraph) */
     961                 :       1080 :         s->client_version=(((int)p[0])<<8)|(int)p[1];
     962                 :       1080 :         p+=2;
     963                 :            : 
     964 [ -  + ][ #  # ]:       1080 :         if (SSL_IS_DTLS(s)  ?   (s->client_version > s->version &&
         [ #  # ][ -  + ]
     965                 :          0 :                                  s->method->version != DTLS_ANY_VERSION)
     966                 :       1080 :                             :   (s->client_version < s->version))
     967                 :            :                 {
     968                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_WRONG_VERSION_NUMBER);
     969 [ #  # ][ #  # ]:          0 :                 if ((s->client_version>>8) == SSL3_VERSION_MAJOR &&
     970         [ #  # ]:          0 :                         !s->enc_write_ctx && !s->write_hash)
     971                 :            :                         {
     972                 :            :                         /* similar to ssl3_get_record, send alert using remote version number */
     973                 :          0 :                         s->version = s->client_version;
     974                 :            :                         }
     975                 :            :                 al = SSL_AD_PROTOCOL_VERSION;
     976                 :            :                 goto f_err;
     977                 :            :                 }
     978                 :            : 
     979                 :            :         /* If we require cookies and this ClientHello doesn't
     980                 :            :          * contain one, just return since we do not want to
     981                 :            :          * allocate any memory yet. So check cookie length...
     982                 :            :          */
     983         [ -  + ]:       1080 :         if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE)
     984                 :            :                 {
     985                 :            :                 unsigned int session_length, cookie_length;
     986                 :            :                 
     987                 :          0 :                 session_length = *(p + SSL3_RANDOM_SIZE);
     988                 :          0 :                 cookie_length = *(p + SSL3_RANDOM_SIZE + session_length + 1);
     989                 :            : 
     990         [ #  # ]:          0 :                 if (cookie_length == 0)
     991                 :            :                         return 1;
     992                 :            :                 }
     993                 :            : 
     994                 :            :         /* load the client random */
     995                 :       1080 :         memcpy(s->s3->client_random,p,SSL3_RANDOM_SIZE);
     996                 :       1080 :         p+=SSL3_RANDOM_SIZE;
     997                 :            : 
     998                 :            :         /* get the session-id */
     999                 :       1080 :         j= *(p++);
    1000                 :            : 
    1001                 :       1080 :         s->hit=0;
    1002                 :            :         /* Versions before 0.9.7 always allow clients to resume sessions in renegotiation.
    1003                 :            :          * 0.9.7 and later allow this by default, but optionally ignore resumption requests
    1004                 :            :          * with flag SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (it's a new flag rather
    1005                 :            :          * than a change to default behavior so that applications relying on this for security
    1006                 :            :          * won't even compile against older library versions).
    1007                 :            :          *
    1008                 :            :          * 1.0.1 and later also have a function SSL_renegotiate_abbreviated() to request
    1009                 :            :          * renegotiation but not a new session (s->new_session remains unset): for servers,
    1010                 :            :          * this essentially just means that the SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
    1011                 :            :          * setting will be ignored.
    1012                 :            :          */
    1013 [ -  + ][ #  # ]:       1080 :         if ((s->new_session && (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION)))
    1014                 :            :                 {
    1015         [ #  # ]:          0 :                 if (!ssl_get_new_session(s,1))
    1016                 :            :                         goto err;
    1017                 :            :                 }
    1018                 :            :         else
    1019                 :            :                 {
    1020                 :       1080 :                 i=ssl_get_prev_session(s, p, j, d + n);
    1021         [ +  + ]:       1080 :                 if (i == 1)
    1022                 :            :                         { /* previous session */
    1023                 :         11 :                         s->hit=1;
    1024                 :            :                         }
    1025         [ +  - ]:       1069 :                 else if (i == -1)
    1026                 :            :                         goto err;
    1027                 :            :                 else /* i == 0 */
    1028                 :            :                         {
    1029         [ +  - ]:       1069 :                         if (!ssl_get_new_session(s,1))
    1030                 :            :                                 goto err;
    1031                 :            :                         }
    1032                 :            :                 }
    1033                 :            : 
    1034                 :       1080 :         p+=j;
    1035                 :            : 
    1036         [ -  + ]:       1080 :         if (SSL_IS_DTLS(s))
    1037                 :            :                 {
    1038                 :            :                 /* cookie stuff */
    1039                 :          0 :                 cookie_len = *(p++);
    1040                 :            : 
    1041                 :            :                 /* 
    1042                 :            :                  * The ClientHello may contain a cookie even if the
    1043                 :            :                  * HelloVerify message has not been sent--make sure that it
    1044                 :            :                  * does not cause an overflow.
    1045                 :            :                  */
    1046         [ #  # ]:          0 :                 if ( cookie_len > sizeof(s->d1->rcvd_cookie))
    1047                 :            :                         {
    1048                 :            :                         /* too much data */
    1049                 :          0 :                         al = SSL_AD_DECODE_ERROR;
    1050                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_COOKIE_MISMATCH);
    1051                 :          0 :                         goto f_err;
    1052                 :            :                         }
    1053                 :            : 
    1054                 :            :                 /* verify the cookie if appropriate option is set. */
    1055 [ #  # ][ #  # ]:          0 :                 if ((SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) &&
    1056                 :            :                         cookie_len > 0)
    1057                 :            :                         {
    1058                 :          0 :                         memcpy(s->d1->rcvd_cookie, p, cookie_len);
    1059                 :            : 
    1060         [ #  # ]:          0 :                         if ( s->ctx->app_verify_cookie_cb != NULL)
    1061                 :            :                                 {
    1062         [ #  # ]:          0 :                                 if ( s->ctx->app_verify_cookie_cb(s, s->d1->rcvd_cookie,
    1063                 :            :                                         cookie_len) == 0)
    1064                 :            :                                         {
    1065                 :          0 :                                         al=SSL_AD_HANDSHAKE_FAILURE;
    1066                 :          0 :                                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, 
    1067                 :            :                                                 SSL_R_COOKIE_MISMATCH);
    1068                 :          0 :                                         goto f_err;
    1069                 :            :                                         }
    1070                 :            :                                 /* else cookie verification succeeded */
    1071                 :            :                                 }
    1072         [ #  # ]:          0 :                         else if ( memcmp(s->d1->rcvd_cookie, s->d1->cookie, 
    1073                 :          0 :                                                   s->d1->cookie_len) != 0) /* default verification */
    1074                 :            :                                 {
    1075                 :          0 :                                         al=SSL_AD_HANDSHAKE_FAILURE;
    1076                 :          0 :                                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, 
    1077                 :            :                                                 SSL_R_COOKIE_MISMATCH);
    1078                 :          0 :                                         goto f_err;
    1079                 :            :                                 }
    1080                 :            :                         /* Set to -2 so if successful we return 2 */
    1081                 :            :                         ret = -2;
    1082                 :            :                         }
    1083                 :            : 
    1084                 :          0 :                 p += cookie_len;
    1085         [ #  # ]:          0 :                 if (s->method->version == DTLS_ANY_VERSION)
    1086                 :            :                         {
    1087                 :            :                         /* Select version to use */
    1088 [ #  # ][ #  # ]:          0 :                         if (s->client_version <= DTLS1_2_VERSION &&
    1089                 :          0 :                                 !(s->options & SSL_OP_NO_DTLSv1_2))
    1090                 :            :                                 {
    1091                 :          0 :                                 s->version = DTLS1_2_VERSION;
    1092                 :          0 :                                 s->method = DTLSv1_2_server_method();
    1093                 :            :                                 }
    1094         [ #  # ]:          0 :                         else if (tls1_suiteb(s))
    1095                 :            :                                 {
    1096                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
    1097                 :          0 :                                 s->version = s->client_version;
    1098                 :          0 :                                 al = SSL_AD_PROTOCOL_VERSION;
    1099                 :          0 :                                 goto f_err;
    1100                 :            :                                 }
    1101 [ #  # ][ #  # ]:          0 :                         else if (s->client_version <= DTLS1_VERSION &&
    1102                 :          0 :                                 !(s->options & SSL_OP_NO_DTLSv1))
    1103                 :            :                                 {
    1104                 :          0 :                                 s->version = DTLS1_VERSION;
    1105                 :          0 :                                 s->method = DTLSv1_server_method();
    1106                 :            :                                 }
    1107                 :            :                         else
    1108                 :            :                                 {
    1109                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_WRONG_VERSION_NUMBER);
    1110                 :          0 :                                 s->version = s->client_version;
    1111                 :          0 :                                 al = SSL_AD_PROTOCOL_VERSION;
    1112                 :          0 :                                 goto f_err;
    1113                 :            :                                 }
    1114                 :          0 :                         s->session->ssl_version = s->version;
    1115                 :            :                         }
    1116                 :            :                 }
    1117                 :            : 
    1118                 :       1080 :         n2s(p,i);
    1119         [ -  + ]:       1080 :         if ((i == 0) && (j != 0))
    1120                 :            :                 {
    1121                 :            :                 /* we need a cipher if we are not resuming a session */
    1122                 :          0 :                 al=SSL_AD_ILLEGAL_PARAMETER;
    1123                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_CIPHERS_SPECIFIED);
    1124                 :          0 :                 goto f_err;
    1125                 :            :                 }
    1126         [ -  + ]:       1080 :         if ((p+i) >= (d+n))
    1127                 :            :                 {
    1128                 :            :                 /* not enough data */
    1129                 :          0 :                 al=SSL_AD_DECODE_ERROR;
    1130                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_LENGTH_MISMATCH);
    1131                 :          0 :                 goto f_err;
    1132                 :            :                 }
    1133 [ +  - ][ +  - ]:       1080 :         if ((i > 0) && (ssl_bytes_to_cipher_list(s,p,i,&(ciphers))
    1134                 :            :                 == NULL))
    1135                 :            :                 {
    1136                 :            :                 goto err;
    1137                 :            :                 }
    1138                 :       1080 :         p+=i;
    1139                 :            : 
    1140                 :            :         /* If it is a hit, check that the cipher is in the list */
    1141 [ +  + ][ +  - ]:       1080 :         if ((s->hit) && (i > 0))
    1142                 :            :                 {
    1143                 :         11 :                 j=0;
    1144                 :         11 :                 id=s->session->cipher->id;
    1145                 :            : 
    1146                 :            : #ifdef CIPHER_DEBUG
    1147                 :            :                 printf("client sent %d ciphers\n",sk_num(ciphers));
    1148                 :            : #endif
    1149         [ +  - ]:         11 :                 for (i=0; i<sk_SSL_CIPHER_num(ciphers); i++)
    1150                 :            :                         {
    1151                 :         11 :                         c=sk_SSL_CIPHER_value(ciphers,i);
    1152                 :            : #ifdef CIPHER_DEBUG
    1153                 :            :                         printf("client [%2d of %2d]:%s\n",
    1154                 :            :                                 i,sk_num(ciphers),SSL_CIPHER_get_name(c));
    1155                 :            : #endif
    1156         [ -  + ]:         11 :                         if (c->id == id)
    1157                 :            :                                 {
    1158                 :            :                                 j=1;
    1159                 :            :                                 break;
    1160                 :            :                                 }
    1161                 :            :                         }
    1162                 :            : /* Disabled because it can be used in a ciphersuite downgrade
    1163                 :            :  * attack: CVE-2010-4180.
    1164                 :            :  */
    1165                 :            : #if 0
    1166                 :            :                 if (j == 0 && (s->options & SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG) && (sk_SSL_CIPHER_num(ciphers) == 1))
    1167                 :            :                         {
    1168                 :            :                         /* Special case as client bug workaround: the previously used cipher may
    1169                 :            :                          * not be in the current list, the client instead might be trying to
    1170                 :            :                          * continue using a cipher that before wasn't chosen due to server
    1171                 :            :                          * preferences.  We'll have to reject the connection if the cipher is not
    1172                 :            :                          * enabled, though. */
    1173                 :            :                         c = sk_SSL_CIPHER_value(ciphers, 0);
    1174                 :            :                         if (sk_SSL_CIPHER_find(SSL_get_ciphers(s), c) >= 0)
    1175                 :            :                                 {
    1176                 :            :                                 s->session->cipher = c;
    1177                 :            :                                 j = 1;
    1178                 :            :                                 }
    1179                 :            :                         }
    1180                 :            : #endif
    1181         [ -  + ]:         11 :                 if (j == 0)
    1182                 :            :                         {
    1183                 :            :                         /* we need to have the cipher in the cipher
    1184                 :            :                          * list if we are asked to reuse it */
    1185                 :          0 :                         al=SSL_AD_ILLEGAL_PARAMETER;
    1186                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_REQUIRED_CIPHER_MISSING);
    1187                 :          0 :                         goto f_err;
    1188                 :            :                         }
    1189                 :            :                 }
    1190                 :            : 
    1191                 :            :         /* compression */
    1192                 :       1080 :         i= *(p++);
    1193         [ +  - ]:       1080 :         if ((p+i) > (d+n))
    1194                 :            :                 {
    1195                 :            :                 /* not enough data */
    1196                 :          0 :                 al=SSL_AD_DECODE_ERROR;
    1197                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_LENGTH_MISMATCH);
    1198                 :          0 :                 goto f_err;
    1199                 :            :                 }
    1200                 :            : #ifndef OPENSSL_NO_COMP
    1201                 :            :         q=p;
    1202                 :            : #endif
    1203         [ +  - ]:       1080 :         for (j=0; j<i; j++)
    1204                 :            :                 {
    1205         [ -  + ]:       1080 :                 if (p[j] == 0) break;
    1206                 :            :                 }
    1207                 :            : 
    1208                 :       1080 :         p+=i;
    1209         [ -  + ]:       1080 :         if (j >= i)
    1210                 :            :                 {
    1211                 :            :                 /* no compress */
    1212                 :          0 :                 al=SSL_AD_DECODE_ERROR;
    1213                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_COMPRESSION_SPECIFIED);
    1214                 :          0 :                 goto f_err;
    1215                 :            :                 }
    1216                 :            : 
    1217                 :            : #ifndef OPENSSL_NO_TLSEXT
    1218                 :            :         /* TLS extensions*/
    1219         [ +  - ]:       1080 :         if (s->version >= SSL3_VERSION)
    1220                 :            :                 {
    1221         [ -  + ]:       1080 :                 if (!ssl_parse_clienthello_tlsext(s,&p,d,n))
    1222                 :            :                         {
    1223                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_PARSE_TLSEXT);
    1224                 :          0 :                         goto err;
    1225                 :            :                         }
    1226                 :            :                 }
    1227                 :            : 
    1228                 :            :         /* Check if we want to use external pre-shared secret for this
    1229                 :            :          * handshake for not reused session only. We need to generate
    1230                 :            :          * server_random before calling tls_session_secret_cb in order to allow
    1231                 :            :          * SessionTicket processing to use it in key derivation. */
    1232                 :            :         {
    1233                 :            :                 unsigned char *pos;
    1234                 :       1080 :                 pos=s->s3->server_random;
    1235         [ +  - ]:       1080 :                 if (ssl_fill_hello_random(s, 1, pos, SSL3_RANDOM_SIZE) <= 0)
    1236                 :            :                         {
    1237                 :            :                         goto f_err;
    1238                 :            :                         }
    1239                 :            :         }
    1240                 :            : 
    1241 [ +  + ][ +  + ]:       1080 :         if (!s->hit && s->version >= TLS1_VERSION && s->tls_session_secret_cb)
                 [ -  + ]
    1242                 :            :                 {
    1243                 :          0 :                 SSL_CIPHER *pref_cipher=NULL;
    1244                 :            : 
    1245                 :          0 :                 s->session->master_key_length=sizeof(s->session->master_key);
    1246         [ #  # ]:          0 :                 if(s->tls_session_secret_cb(s, s->session->master_key, &s->session->master_key_length,
    1247                 :            :                         ciphers, &pref_cipher, s->tls_session_secret_cb_arg))
    1248                 :            :                         {
    1249                 :          0 :                         s->hit=1;
    1250                 :          0 :                         s->session->ciphers=ciphers;
    1251                 :          0 :                         s->session->verify_result=X509_V_OK;
    1252                 :            : 
    1253                 :          0 :                         ciphers=NULL;
    1254                 :            : 
    1255                 :            :                         /* check if some cipher was preferred by call back */
    1256         [ #  # ]:          0 :                         pref_cipher=pref_cipher ? pref_cipher : ssl3_choose_cipher(s, s->session->ciphers, SSL_get_ciphers(s));
    1257         [ #  # ]:          0 :                         if (pref_cipher == NULL)
    1258                 :            :                                 {
    1259                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    1260                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_SHARED_CIPHER);
    1261                 :          0 :                                 goto f_err;
    1262                 :            :                                 }
    1263                 :            : 
    1264                 :          0 :                         s->session->cipher=pref_cipher;
    1265                 :            : 
    1266         [ #  # ]:          0 :                         if (s->cipher_list)
    1267                 :          0 :                                 sk_SSL_CIPHER_free(s->cipher_list);
    1268                 :            : 
    1269         [ #  # ]:          0 :                         if (s->cipher_list_by_id)
    1270                 :          0 :                                 sk_SSL_CIPHER_free(s->cipher_list_by_id);
    1271                 :            : 
    1272                 :          0 :                         s->cipher_list = sk_SSL_CIPHER_dup(s->session->ciphers);
    1273                 :          0 :                         s->cipher_list_by_id = sk_SSL_CIPHER_dup(s->session->ciphers);
    1274                 :            :                         }
    1275                 :            :                 }
    1276                 :            : #endif
    1277                 :            : 
    1278                 :            :         /* Worst case, we will use the NULL compression, but if we have other
    1279                 :            :          * options, we will now look for them.  We have i-1 compression
    1280                 :            :          * algorithms from the client, starting at q. */
    1281                 :       1080 :         s->s3->tmp.new_compression=NULL;
    1282                 :            : #ifndef OPENSSL_NO_COMP
    1283                 :            :         /* This only happens if we have a cache hit */
    1284         [ -  + ]:       1080 :         if (s->session->compress_meth != 0)
    1285                 :            :                 {
    1286                 :          0 :                 int m, comp_id = s->session->compress_meth;
    1287                 :            :                 /* Perform sanity checks on resumed compression algorithm */
    1288                 :            :                 /* Can't disable compression */
    1289         [ #  # ]:          0 :                 if (!ssl_allow_compression(s))
    1290                 :            :                         {
    1291                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_INCONSISTENT_COMPRESSION);
    1292                 :          0 :                         goto f_err;
    1293                 :            :                         }
    1294                 :            :                 /* Look for resumed compression method */
    1295         [ #  # ]:          0 :                 for (m = 0; m < sk_SSL_COMP_num(s->ctx->comp_methods); m++)
    1296                 :            :                         {
    1297                 :          0 :                         comp=sk_SSL_COMP_value(s->ctx->comp_methods,m);
    1298         [ #  # ]:          0 :                         if (comp_id == comp->id)
    1299                 :            :                                 {
    1300                 :          0 :                                 s->s3->tmp.new_compression=comp;
    1301                 :          0 :                                 break;
    1302                 :            :                                 }
    1303                 :            :                         }
    1304         [ #  # ]:          0 :                 if (s->s3->tmp.new_compression == NULL)
    1305                 :            :                         {
    1306                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_INVALID_COMPRESSION_ALGORITHM);
    1307                 :          0 :                         goto f_err;
    1308                 :            :                         }
    1309                 :            :                 /* Look for resumed method in compression list */
    1310         [ #  # ]:          0 :                 for (m = 0; m < i; m++)
    1311                 :            :                         {
    1312         [ #  # ]:          0 :                         if (q[m] == comp_id)
    1313                 :            :                                 break;
    1314                 :            :                         }
    1315         [ #  # ]:          0 :                 if (m >= i)
    1316                 :            :                         {
    1317                 :          0 :                         al=SSL_AD_ILLEGAL_PARAMETER;
    1318                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_REQUIRED_COMPRESSSION_ALGORITHM_MISSING);
    1319                 :          0 :                         goto f_err;
    1320                 :            :                         }
    1321                 :            :                 }
    1322         [ +  + ]:       1080 :         else if (s->hit)
    1323                 :            :                 comp = NULL;
    1324 [ +  - ][ +  - ]:       1069 :         else if (ssl_allow_compression(s) && s->ctx->comp_methods)
    1325                 :            :                 { /* See if we have a match */
    1326                 :       1069 :                 int m,nn,o,v,done=0;
    1327                 :            : 
    1328                 :       1069 :                 nn=sk_SSL_COMP_num(s->ctx->comp_methods);
    1329         [ -  + ]:       1069 :                 for (m=0; m<nn; m++)
    1330                 :            :                         {
    1331                 :          0 :                         comp=sk_SSL_COMP_value(s->ctx->comp_methods,m);
    1332                 :          0 :                         v=comp->id;
    1333         [ #  # ]:          0 :                         for (o=0; o<i; o++)
    1334                 :            :                                 {
    1335         [ #  # ]:          0 :                                 if (v == q[o])
    1336                 :            :                                         {
    1337                 :            :                                         done=1;
    1338                 :            :                                         break;
    1339                 :            :                                         }
    1340                 :            :                                 }
    1341         [ #  # ]:          0 :                         if (done) break;
    1342                 :            :                         }
    1343         [ -  + ]:       1069 :                 if (done)
    1344                 :          0 :                         s->s3->tmp.new_compression=comp;
    1345                 :            :                 else
    1346                 :            :                         comp=NULL;
    1347                 :            :                 }
    1348                 :            : #else
    1349                 :            :         /* If compression is disabled we'd better not try to resume a session
    1350                 :            :          * using compression.
    1351                 :            :          */
    1352                 :            :         if (s->session->compress_meth != 0)
    1353                 :            :                 {
    1354                 :            :                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_INCONSISTENT_COMPRESSION);
    1355                 :            :                 goto f_err;
    1356                 :            :                 }
    1357                 :            : #endif
    1358                 :            : 
    1359                 :            :         /* Given s->session->ciphers and SSL_get_ciphers, we must
    1360                 :            :          * pick a cipher */
    1361                 :            : 
    1362         [ +  + ]:       1080 :         if (!s->hit)
    1363                 :            :                 {
    1364                 :            : #ifdef OPENSSL_NO_COMP
    1365                 :            :                 s->session->compress_meth=0;
    1366                 :            : #else
    1367         [ -  + ]:       1069 :                 s->session->compress_meth=(comp == NULL)?0:comp->id;
    1368                 :            : #endif
    1369         [ -  + ]:       1069 :                 if (s->session->ciphers != NULL)
    1370                 :          0 :                         sk_SSL_CIPHER_free(s->session->ciphers);
    1371                 :       1069 :                 s->session->ciphers=ciphers;
    1372         [ -  + ]:       1069 :                 if (ciphers == NULL)
    1373                 :            :                         {
    1374                 :          0 :                         al=SSL_AD_ILLEGAL_PARAMETER;
    1375                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_CIPHERS_PASSED);
    1376                 :          0 :                         goto f_err;
    1377                 :            :                         }
    1378                 :       1069 :                 ciphers=NULL;
    1379                 :            :                 /* Let cert callback update server certificates if required */
    1380                 :            :                 retry_cert:             
    1381         [ -  + ]:       1069 :                 if (s->cert->cert_cb)
    1382                 :            :                         {
    1383                 :          0 :                         int rv = s->cert->cert_cb(s, s->cert->cert_cb_arg);
    1384         [ #  # ]:          0 :                         if (rv == 0)
    1385                 :            :                                 {
    1386                 :          0 :                                 al=SSL_AD_INTERNAL_ERROR;
    1387                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_CERT_CB_ERROR);
    1388                 :          0 :                                 goto f_err;
    1389                 :            :                                 }
    1390         [ #  # ]:          0 :                         if (rv < 0)
    1391                 :            :                                 {
    1392                 :          0 :                                 s->rwstate=SSL_X509_LOOKUP;
    1393                 :          0 :                                 return -1;
    1394                 :            :                                 }
    1395                 :          0 :                         s->rwstate = SSL_NOTHING;
    1396                 :            :                         }
    1397                 :       1069 :                 c=ssl3_choose_cipher(s,s->session->ciphers,
    1398                 :            :                                      SSL_get_ciphers(s));
    1399                 :            : 
    1400         [ -  + ]:       1069 :                 if (c == NULL)
    1401                 :            :                         {
    1402                 :          0 :                         al=SSL_AD_HANDSHAKE_FAILURE;
    1403                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_SHARED_CIPHER);
    1404                 :          0 :                         goto f_err;
    1405                 :            :                         }
    1406                 :       1069 :                 s->s3->tmp.new_cipher=c;
    1407                 :            :                 /* check whether we should disable session resumption */
    1408         [ -  + ]:       1069 :                 if (s->not_resumable_session_cb != NULL)
    1409                 :          0 :                         s->session->not_resumable=s->not_resumable_session_cb(s,
    1410                 :          0 :                                 ((c->algorithm_mkey & (SSL_kDHE | SSL_kECDHE)) != 0));
    1411         [ -  + ]:       1069 :                 if (s->session->not_resumable)
    1412                 :            :                         /* do not send a session ticket */
    1413                 :          0 :                         s->tlsext_ticket_expected = 0;
    1414                 :            :                 }
    1415                 :            :         else
    1416                 :            :                 {
    1417                 :            :                 /* Session-id reuse */
    1418                 :            : #ifdef REUSE_CIPHER_BUG
    1419                 :            :                 STACK_OF(SSL_CIPHER) *sk;
    1420                 :         11 :                 SSL_CIPHER *nc=NULL;
    1421                 :         11 :                 SSL_CIPHER *ec=NULL;
    1422                 :            : 
    1423         [ -  + ]:         11 :                 if (s->options & SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG)
    1424                 :            :                         {
    1425                 :          0 :                         sk=s->session->ciphers;
    1426         [ #  # ]:          0 :                         for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
    1427                 :            :                                 {
    1428                 :          0 :                                 c=sk_SSL_CIPHER_value(sk,i);
    1429         [ #  # ]:          0 :                                 if (c->algorithm_enc & SSL_eNULL)
    1430                 :          0 :                                         nc=c;
    1431         [ #  # ]:          0 :                                 if (SSL_C_IS_EXPORT(c))
    1432                 :          0 :                                         ec=c;
    1433                 :            :                                 }
    1434         [ #  # ]:          0 :                         if (nc != NULL)
    1435                 :          0 :                                 s->s3->tmp.new_cipher=nc;
    1436         [ #  # ]:          0 :                         else if (ec != NULL)
    1437                 :          0 :                                 s->s3->tmp.new_cipher=ec;
    1438                 :            :                         else
    1439                 :          0 :                                 s->s3->tmp.new_cipher=s->session->cipher;
    1440                 :            :                         }
    1441                 :            :                 else
    1442                 :            : #endif
    1443                 :         11 :                 s->s3->tmp.new_cipher=s->session->cipher;
    1444                 :            :                 }
    1445                 :            : 
    1446 [ +  + ][ +  + ]:       1080 :         if (!SSL_USE_SIGALGS(s) || !(s->verify_mode & SSL_VERIFY_PEER))
    1447                 :            :                 {
    1448         [ +  - ]:       1025 :                 if (!ssl3_digest_cached_records(s))
    1449                 :            :                         goto f_err;
    1450                 :            :                 }
    1451                 :            :         
    1452                 :            :         /* we now have the following setup. 
    1453                 :            :          * client_random
    1454                 :            :          * cipher_list          - our prefered list of ciphers
    1455                 :            :          * ciphers              - the clients prefered list of ciphers
    1456                 :            :          * compression          - basically ignored right now
    1457                 :            :          * ssl version is set   - sslv3
    1458                 :            :          * s->session                - The ssl session has been setup.
    1459                 :            :          * s->hit            - session reuse flag
    1460                 :            :          * s->s3->tmp.new_cipher- the new cipher to use.
    1461                 :            :          */
    1462                 :            : 
    1463                 :            :         /* Handles TLS extensions that we couldn't check earlier */
    1464         [ +  - ]:       1080 :         if (s->version >= SSL3_VERSION)
    1465                 :            :                 {
    1466         [ -  + ]:       1080 :                 if (ssl_check_clienthello_tlsext_late(s) <= 0)
    1467                 :            :                         {
    1468                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
    1469                 :          0 :                         goto err;
    1470                 :            :                         }
    1471                 :            :                 }
    1472                 :            : 
    1473                 :       1080 :         if (ret < 0) ret=-ret;
    1474                 :            :         if (0)
    1475                 :            :                 {
    1476                 :            : f_err:
    1477                 :          0 :                 ssl3_send_alert(s,SSL3_AL_FATAL,al);
    1478                 :            :                 }
    1479                 :            : err:
    1480         [ +  + ]:       1080 :         if (ciphers != NULL) sk_SSL_CIPHER_free(ciphers);
    1481                 :       1080 :         return ret < 0 ? -1 : ret;
    1482                 :            :         }
    1483                 :            : 
    1484                 :       1080 : int ssl3_send_server_hello(SSL *s)
    1485                 :            :         {
    1486                 :            :         unsigned char *buf;
    1487                 :            :         unsigned char *p,*d;
    1488                 :            :         int i,sl;
    1489                 :       1080 :         int al = 0;
    1490                 :            :         unsigned long l;
    1491                 :            : 
    1492         [ +  - ]:       1080 :         if (s->state == SSL3_ST_SW_SRVR_HELLO_A)
    1493                 :            :                 {
    1494                 :       1080 :                 buf=(unsigned char *)s->init_buf->data;
    1495                 :            : #ifdef OPENSSL_NO_TLSEXT
    1496                 :            :                 p=s->s3->server_random;
    1497                 :            :                 if (ssl_fill_hello_random(s, 1, p, SSL3_RANDOM_SIZE) <= 0)
    1498                 :            :                         return -1;
    1499                 :            : #endif
    1500                 :            :                 /* Do the message type and length last */
    1501                 :       1080 :                 d=p= ssl_handshake_start(s);
    1502                 :            : 
    1503                 :       1080 :                 *(p++)=s->version>>8;
    1504                 :       1080 :                 *(p++)=s->version&0xff;
    1505                 :            : 
    1506                 :            :                 /* Random stuff */
    1507                 :       1080 :                 memcpy(p,s->s3->server_random,SSL3_RANDOM_SIZE);
    1508                 :       1080 :                 p+=SSL3_RANDOM_SIZE;
    1509                 :            : 
    1510                 :            :                 /* There are several cases for the session ID to send
    1511                 :            :                  * back in the server hello:
    1512                 :            :                  * - For session reuse from the session cache,
    1513                 :            :                  *   we send back the old session ID.
    1514                 :            :                  * - If stateless session reuse (using a session ticket)
    1515                 :            :                  *   is successful, we send back the client's "session ID"
    1516                 :            :                  *   (which doesn't actually identify the session).
    1517                 :            :                  * - If it is a new session, we send back the new
    1518                 :            :                  *   session ID.
    1519                 :            :                  * - However, if we want the new session to be single-use,
    1520                 :            :                  *   we send back a 0-length session ID.
    1521                 :            :                  * s->hit is non-zero in either case of session reuse,
    1522                 :            :                  * so the following won't overwrite an ID that we're supposed
    1523                 :            :                  * to send back.
    1524                 :            :                  */
    1525 [ +  - ][ -  + ]:       1080 :                 if (s->session->not_resumable ||
    1526                 :       1080 :                         (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)
    1527         [ #  # ]:          0 :                                 && !s->hit))
    1528                 :          0 :                         s->session->session_id_length=0;
    1529                 :            : 
    1530                 :       1080 :                 sl=s->session->session_id_length;
    1531         [ -  + ]:       1080 :                 if (sl > (int)sizeof(s->session->session_id))
    1532                 :            :                         {
    1533                 :          0 :                         SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
    1534                 :          0 :                         return -1;
    1535                 :            :                         }
    1536                 :       1080 :                 *(p++)=sl;
    1537                 :       1080 :                 memcpy(p,s->session->session_id,sl);
    1538                 :       1080 :                 p+=sl;
    1539                 :            : 
    1540                 :            :                 /* put the cipher */
    1541                 :       1080 :                 i=ssl3_put_cipher_by_char(s->s3->tmp.new_cipher,p);
    1542                 :       1080 :                 p+=i;
    1543                 :            : 
    1544                 :            :                 /* put the compression method */
    1545                 :            : #ifdef OPENSSL_NO_COMP
    1546                 :            :                         *(p++)=0;
    1547                 :            : #else
    1548         [ +  - ]:       1080 :                 if (s->s3->tmp.new_compression == NULL)
    1549                 :       1080 :                         *(p++)=0;
    1550                 :            :                 else
    1551                 :          0 :                         *(p++)=s->s3->tmp.new_compression->id;
    1552                 :            : #endif
    1553                 :            : #ifndef OPENSSL_NO_TLSEXT
    1554         [ -  + ]:       1080 :                 if (ssl_prepare_serverhello_tlsext(s) <= 0)
    1555                 :            :                         {
    1556                 :          0 :                         SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO,SSL_R_SERVERHELLO_TLSEXT);
    1557                 :          0 :                         return -1;
    1558                 :            :                         }
    1559         [ -  + ]:       1080 :                 if ((p = ssl_add_serverhello_tlsext(s, p, buf+SSL3_RT_MAX_PLAIN_LENGTH, &al)) == NULL)
    1560                 :            :                         {
    1561                 :          0 :                         ssl3_send_alert(s, SSL3_AL_FATAL, al);
    1562                 :          0 :                         SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO,ERR_R_INTERNAL_ERROR);
    1563                 :          0 :                         return -1;
    1564                 :            :                         }
    1565                 :            : #endif
    1566                 :            :                 /* do the header */
    1567                 :       1080 :                 l=(p-d);
    1568                 :       1080 :                 ssl_set_handshake_header(s, SSL3_MT_SERVER_HELLO, l);
    1569                 :       1080 :                 s->state=SSL3_ST_SW_SRVR_HELLO_B;
    1570                 :            :                 }
    1571                 :            : 
    1572                 :            :         /* SSL3_ST_SW_SRVR_HELLO_B */
    1573                 :       1080 :         return ssl_do_write(s);
    1574                 :            :         }
    1575                 :            : 
    1576                 :        970 : int ssl3_send_server_done(SSL *s)
    1577                 :            :         {
    1578                 :            : 
    1579         [ +  - ]:        970 :         if (s->state == SSL3_ST_SW_SRVR_DONE_A)
    1580                 :            :                 {
    1581                 :        970 :                 ssl_set_handshake_header(s, SSL3_MT_SERVER_DONE, 0);
    1582                 :        970 :                 s->state = SSL3_ST_SW_SRVR_DONE_B;
    1583                 :            :                 }
    1584                 :            : 
    1585                 :            :         /* SSL3_ST_SW_SRVR_DONE_B */
    1586                 :        970 :         return ssl_do_write(s);
    1587                 :            :         }
    1588                 :            : 
    1589                 :        737 : int ssl3_send_server_key_exchange(SSL *s)
    1590                 :            :         {
    1591                 :            : #ifndef OPENSSL_NO_RSA
    1592                 :            :         unsigned char *q;
    1593                 :            :         int j,num;
    1594                 :            :         RSA *rsa;
    1595                 :            :         unsigned char md_buf[MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH];
    1596                 :            :         unsigned int u;
    1597                 :            : #endif
    1598                 :            : #ifndef OPENSSL_NO_DH
    1599                 :        737 :         DH *dh=NULL,*dhp;
    1600                 :            : #endif
    1601                 :            : #ifndef OPENSSL_NO_ECDH
    1602                 :        737 :         EC_KEY *ecdh=NULL, *ecdhp;
    1603                 :        737 :         unsigned char *encodedPoint = NULL;
    1604                 :        737 :         int encodedlen = 0;
    1605                 :        737 :         int curve_id = 0;
    1606                 :        737 :         BN_CTX *bn_ctx = NULL; 
    1607                 :            : #endif
    1608                 :            :         EVP_PKEY *pkey;
    1609                 :        737 :         const EVP_MD *md = NULL;
    1610                 :            :         unsigned char *p,*d;
    1611                 :            :         int al,i;
    1612                 :            :         unsigned long type;
    1613                 :            :         int n;
    1614                 :            :         CERT *cert;
    1615                 :            :         BIGNUM *r[4];
    1616                 :            :         int nr[4],kn;
    1617                 :            :         BUF_MEM *buf;
    1618                 :            :         EVP_MD_CTX md_ctx;
    1619                 :            : 
    1620                 :        737 :         EVP_MD_CTX_init(&md_ctx);
    1621         [ +  - ]:        737 :         if (s->state == SSL3_ST_SW_KEY_EXCH_A)
    1622                 :            :                 {
    1623                 :        737 :                 type=s->s3->tmp.new_cipher->algorithm_mkey;
    1624                 :        737 :                 cert=s->cert;
    1625                 :            : 
    1626                 :        737 :                 buf=s->init_buf;
    1627                 :            : 
    1628                 :        737 :                 r[0]=r[1]=r[2]=r[3]=NULL;
    1629                 :        737 :                 n=0;
    1630                 :            : #ifndef OPENSSL_NO_RSA
    1631         [ +  + ]:        737 :                 if (type & SSL_kRSA)
    1632                 :            :                         {
    1633                 :         33 :                         rsa=cert->rsa_tmp;
    1634 [ +  - ][ +  - ]:         33 :                         if ((rsa == NULL) && (s->cert->rsa_tmp_cb != NULL))
    1635                 :            :                                 {
    1636         [ -  + ]:         33 :                                 rsa=s->cert->rsa_tmp_cb(s,
    1637                 :            :                                       SSL_C_IS_EXPORT(s->s3->tmp.new_cipher),
    1638                 :         33 :                                       SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher));
    1639         [ -  + ]:         33 :                                 if(rsa == NULL)
    1640                 :            :                                 {
    1641                 :          0 :                                         al=SSL_AD_HANDSHAKE_FAILURE;
    1642                 :          0 :                                         SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_ERROR_GENERATING_TMP_RSA_KEY);
    1643                 :          0 :                                         goto f_err;
    1644                 :            :                                 }
    1645                 :         33 :                                 RSA_up_ref(rsa);
    1646                 :         33 :                                 cert->rsa_tmp=rsa;
    1647                 :            :                                 }
    1648         [ -  + ]:         33 :                         if (rsa == NULL)
    1649                 :            :                                 {
    1650                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    1651                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_TMP_RSA_KEY);
    1652                 :          0 :                                 goto f_err;
    1653                 :            :                                 }
    1654                 :         33 :                         r[0]=rsa->n;
    1655                 :         33 :                         r[1]=rsa->e;
    1656                 :         33 :                         s->s3->tmp.use_rsa_tmp=1;
    1657                 :            :                         }
    1658                 :            :                 else
    1659                 :            : #endif
    1660                 :            : #ifndef OPENSSL_NO_DH
    1661         [ +  + ]:        704 :                         if (type & SSL_kDHE)
    1662                 :            :                         {
    1663         [ -  + ]:        198 :                         if (s->cert->dh_tmp_auto)
    1664                 :            :                                 {
    1665                 :          0 :                                 dhp = ssl_get_auto_dh(s);
    1666         [ #  # ]:          0 :                                 if (dhp == NULL)
    1667                 :            :                                         {
    1668                 :          0 :                                         al=SSL_AD_INTERNAL_ERROR;
    1669                 :          0 :                                         SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
    1670                 :          0 :                                         goto f_err;
    1671                 :            :                                         }
    1672                 :            :                                 }
    1673                 :            :                         else
    1674                 :        198 :                                 dhp=cert->dh_tmp;
    1675 [ -  + ][ #  # ]:        198 :                         if ((dhp == NULL) && (s->cert->dh_tmp_cb != NULL))
    1676         [ #  # ]:          0 :                                 dhp=s->cert->dh_tmp_cb(s,
    1677                 :            :                                       SSL_C_IS_EXPORT(s->s3->tmp.new_cipher),
    1678                 :          0 :                                       SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher));
    1679         [ -  + ]:        198 :                         if (dhp == NULL)
    1680                 :            :                                 {
    1681                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    1682                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_TMP_DH_KEY);
    1683                 :          0 :                                 goto f_err;
    1684                 :            :                                 }
    1685         [ -  + ]:        198 :                         if (!ssl_security(s, SSL_SECOP_TMP_DH,
    1686                 :            :                                                 DH_security_bits(dhp), 0, dhp))
    1687                 :            :                                 {
    1688                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    1689                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_DH_KEY_TOO_SMALL);
    1690                 :          0 :                                 goto f_err;
    1691                 :            :                                 }
    1692         [ -  + ]:        198 :                         if (s->s3->tmp.dh != NULL)
    1693                 :            :                                 {
    1694                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
    1695                 :          0 :                                 goto err;
    1696                 :            :                                 }
    1697                 :            : 
    1698         [ +  - ]:        198 :                         if (s->cert->dh_tmp_auto)
    1699                 :            :                                 dh = dhp;
    1700         [ -  + ]:        198 :                         else if ((dh=DHparams_dup(dhp)) == NULL)
    1701                 :            :                                 {
    1702                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_DH_LIB);
    1703                 :          0 :                                 goto err;
    1704                 :            :                                 }
    1705                 :            : 
    1706                 :        198 :                         s->s3->tmp.dh=dh;
    1707 [ +  + ][ +  - ]:        198 :                         if ((dhp->pub_key == NULL ||
    1708         [ -  + ]:         88 :                              dhp->priv_key == NULL ||
    1709                 :         88 :                              (s->options & SSL_OP_SINGLE_DH_USE)))
    1710                 :            :                                 {
    1711         [ -  + ]:        110 :                                 if(!DH_generate_key(dh))
    1712                 :            :                                     {
    1713                 :          0 :                                     SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
    1714                 :            :                                            ERR_R_DH_LIB);
    1715                 :          0 :                                     goto err;
    1716                 :            :                                     }
    1717                 :            :                                 }
    1718                 :            :                         else
    1719                 :            :                                 {
    1720                 :         88 :                                 dh->pub_key=BN_dup(dhp->pub_key);
    1721                 :         88 :                                 dh->priv_key=BN_dup(dhp->priv_key);
    1722 [ +  - ][ -  + ]:         88 :                                 if ((dh->pub_key == NULL) ||
    1723                 :            :                                         (dh->priv_key == NULL))
    1724                 :            :                                         {
    1725                 :          0 :                                         SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_DH_LIB);
    1726                 :          0 :                                         goto err;
    1727                 :            :                                         }
    1728                 :            :                                 }
    1729                 :        198 :                         r[0]=dh->p;
    1730                 :        198 :                         r[1]=dh->g;
    1731                 :        198 :                         r[2]=dh->pub_key;
    1732                 :            :                         }
    1733                 :            :                 else 
    1734                 :            : #endif
    1735                 :            : #ifndef OPENSSL_NO_ECDH
    1736         [ +  + ]:        506 :                         if (type & SSL_kECDHE)
    1737                 :            :                         {
    1738                 :            :                         const EC_GROUP *group;
    1739                 :            : 
    1740                 :        462 :                         ecdhp=cert->ecdh_tmp;
    1741         [ -  + ]:        462 :                         if (s->cert->ecdh_tmp_auto)
    1742                 :            :                                 {
    1743                 :            :                                 /* Get NID of appropriate shared curve */
    1744                 :          0 :                                 int nid = tls1_shared_curve(s, -2);
    1745         [ #  # ]:          0 :                                 if (nid != NID_undef)
    1746                 :          0 :                                         ecdhp = EC_KEY_new_by_curve_name(nid);
    1747                 :            :                                 }
    1748 [ -  + ][ #  # ]:        462 :                         else if ((ecdhp == NULL) && s->cert->ecdh_tmp_cb)
    1749                 :            :                                 {
    1750         [ #  # ]:          0 :                                 ecdhp=s->cert->ecdh_tmp_cb(s,
    1751                 :            :                                       SSL_C_IS_EXPORT(s->s3->tmp.new_cipher),
    1752                 :          0 :                                       SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher));
    1753                 :            :                                 }
    1754         [ -  + ]:        462 :                         if (ecdhp == NULL)
    1755                 :            :                                 {
    1756                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    1757                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_TMP_ECDH_KEY);
    1758                 :          0 :                                 goto f_err;
    1759                 :            :                                 }
    1760                 :            : 
    1761         [ -  + ]:        462 :                         if (s->s3->tmp.ecdh != NULL)
    1762                 :            :                                 {
    1763                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
    1764                 :          0 :                                 goto err;
    1765                 :            :                                 }
    1766                 :            : 
    1767                 :            :                         /* Duplicate the ECDH structure. */
    1768         [ -  + ]:        462 :                         if (ecdhp == NULL)
    1769                 :            :                                 {
    1770                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB);
    1771                 :          0 :                                 goto err;
    1772                 :            :                                 }
    1773         [ +  - ]:        462 :                         if (s->cert->ecdh_tmp_auto)
    1774                 :            :                                 ecdh = ecdhp;
    1775         [ -  + ]:        462 :                         else if ((ecdh = EC_KEY_dup(ecdhp)) == NULL)
    1776                 :            :                                 {
    1777                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB);
    1778                 :          0 :                                 goto err;
    1779                 :            :                                 }
    1780                 :            : 
    1781                 :        462 :                         s->s3->tmp.ecdh=ecdh;
    1782   [ +  -  +  - ]:        924 :                         if ((EC_KEY_get0_public_key(ecdh) == NULL) ||
    1783         [ +  - ]:        924 :                             (EC_KEY_get0_private_key(ecdh) == NULL) ||
    1784                 :        462 :                             (s->options & SSL_OP_SINGLE_ECDH_USE))
    1785                 :            :                                 {
    1786         [ -  + ]:        462 :                                 if(!EC_KEY_generate_key(ecdh))
    1787                 :            :                                     {
    1788                 :          0 :                                     SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB);
    1789                 :          0 :                                     goto err;
    1790                 :            :                                     }
    1791                 :            :                                 }
    1792                 :            : 
    1793   [ +  -  +  - ]:        924 :                         if (((group = EC_KEY_get0_group(ecdh)) == NULL) ||
    1794         [ -  + ]:        924 :                             (EC_KEY_get0_public_key(ecdh)  == NULL) ||
    1795                 :        462 :                             (EC_KEY_get0_private_key(ecdh) == NULL))
    1796                 :            :                                 {
    1797                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB);
    1798                 :          0 :                                 goto err;
    1799                 :            :                                 }
    1800                 :            : 
    1801   [ -  +  #  # ]:        462 :                         if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
    1802                 :          0 :                             (EC_GROUP_get_degree(group) > 163)) 
    1803                 :            :                                 {
    1804                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER);
    1805                 :          0 :                                 goto err;
    1806                 :            :                                 }
    1807                 :            : 
    1808                 :            :                         /* XXX: For now, we only support ephemeral ECDH
    1809                 :            :                          * keys over named (not generic) curves. For 
    1810                 :            :                          * supported named curves, curve_id is non-zero.
    1811                 :            :                          */
    1812         [ -  + ]:        462 :                         if ((curve_id = 
    1813                 :        462 :                             tls1_ec_nid2curve_id(EC_GROUP_get_curve_name(group)))
    1814                 :            :                             == 0)
    1815                 :            :                                 {
    1816                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_UNSUPPORTED_ELLIPTIC_CURVE);
    1817                 :          0 :                                 goto err;
    1818                 :            :                                 }
    1819                 :            : 
    1820                 :            :                         /* Encode the public key.
    1821                 :            :                          * First check the size of encoding and
    1822                 :            :                          * allocate memory accordingly.
    1823                 :            :                          */
    1824                 :        462 :                         encodedlen = EC_POINT_point2oct(group, 
    1825                 :            :                             EC_KEY_get0_public_key(ecdh),
    1826                 :            :                             POINT_CONVERSION_UNCOMPRESSED, 
    1827                 :            :                             NULL, 0, NULL);
    1828                 :            : 
    1829                 :        462 :                         encodedPoint = (unsigned char *) 
    1830                 :            :                             OPENSSL_malloc(encodedlen*sizeof(unsigned char)); 
    1831                 :        462 :                         bn_ctx = BN_CTX_new();
    1832         [ -  + ]:        462 :                         if ((encodedPoint == NULL) || (bn_ctx == NULL))
    1833                 :            :                                 {
    1834                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE);
    1835                 :          0 :                                 goto err;
    1836                 :            :                                 }
    1837                 :            : 
    1838                 :            : 
    1839                 :        462 :                         encodedlen = EC_POINT_point2oct(group, 
    1840                 :            :                             EC_KEY_get0_public_key(ecdh), 
    1841                 :            :                             POINT_CONVERSION_UNCOMPRESSED, 
    1842                 :            :                             encodedPoint, encodedlen, bn_ctx);
    1843                 :            : 
    1844         [ -  + ]:        462 :                         if (encodedlen == 0) 
    1845                 :            :                                 {
    1846                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB);
    1847                 :          0 :                                 goto err;
    1848                 :            :                                 }
    1849                 :            : 
    1850                 :        462 :                         BN_CTX_free(bn_ctx);  bn_ctx=NULL;
    1851                 :            : 
    1852                 :            :                         /* XXX: For now, we only support named (not 
    1853                 :            :                          * generic) curves in ECDH ephemeral key exchanges.
    1854                 :            :                          * In this situation, we need four additional bytes
    1855                 :            :                          * to encode the entire ServerECDHParams
    1856                 :            :                          * structure. 
    1857                 :            :                          */
    1858                 :        462 :                         n = 4 + encodedlen;
    1859                 :            : 
    1860                 :            :                         /* We'll generate the serverKeyExchange message
    1861                 :            :                          * explicitly so we can set these to NULLs
    1862                 :            :                          */
    1863                 :        462 :                         r[0]=NULL;
    1864                 :        462 :                         r[1]=NULL;
    1865                 :        462 :                         r[2]=NULL;
    1866                 :        462 :                         r[3]=NULL;
    1867                 :            :                         }
    1868                 :            :                 else 
    1869                 :            : #endif /* !OPENSSL_NO_ECDH */
    1870                 :            : #ifndef OPENSSL_NO_PSK
    1871         [ +  + ]:         44 :                         if (type & SSL_kPSK)
    1872                 :            :                                 {
    1873                 :            :                                 /* reserve size for record length and PSK identity hint*/
    1874                 :         22 :                                 n+=2+strlen(s->ctx->psk_identity_hint);
    1875                 :            :                                 }
    1876                 :            :                         else
    1877                 :            : #endif /* !OPENSSL_NO_PSK */
    1878                 :            : #ifndef OPENSSL_NO_SRP
    1879         [ +  - ]:         22 :                 if (type & SSL_kSRP)
    1880                 :            :                         {
    1881 [ +  - ][ +  - ]:         22 :                         if ((s->srp_ctx.N == NULL) ||
    1882         [ +  - ]:         22 :                                 (s->srp_ctx.g == NULL) ||
    1883         [ -  + ]:         22 :                                 (s->srp_ctx.s == NULL) ||
    1884                 :         22 :                                 (s->srp_ctx.B == NULL))
    1885                 :            :                                 {
    1886                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_SRP_PARAM);
    1887                 :          0 :                                 goto err;
    1888                 :            :                                 }
    1889                 :         22 :                         r[0]=s->srp_ctx.N;
    1890                 :         22 :                         r[1]=s->srp_ctx.g;
    1891                 :         22 :                         r[2]=s->srp_ctx.s;
    1892                 :         22 :                         r[3]=s->srp_ctx.B;
    1893                 :            :                         }
    1894                 :            :                 else 
    1895                 :            : #endif
    1896                 :            :                         {
    1897                 :          0 :                         al=SSL_AD_HANDSHAKE_FAILURE;
    1898                 :          0 :                         SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
    1899                 :          0 :                         goto f_err;
    1900                 :            :                         }
    1901 [ +  + ][ +  + ]:       1485 :                 for (i=0; i < 4 && r[i] != NULL; i++)
    1902                 :            :                         {
    1903                 :        748 :                         nr[i]=BN_num_bytes(r[i]);
    1904                 :            : #ifndef OPENSSL_NO_SRP
    1905 [ +  + ][ +  + ]:        748 :                         if ((i == 2) && (type & SSL_kSRP))
    1906                 :         22 :                                 n+=1+nr[i];
    1907                 :            :                         else
    1908                 :            : #endif
    1909                 :        726 :                         n+=2+nr[i];
    1910                 :            :                         }
    1911                 :            : 
    1912         [ +  + ]:        737 :                 if (!(s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL)
    1913         [ +  + ]:        627 :                         && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK))
    1914                 :            :                         {
    1915         [ +  - ]:        605 :                         if ((pkey=ssl_get_sign_pkey(s,s->s3->tmp.new_cipher,&md))
    1916                 :            :                                 == NULL)
    1917                 :            :                                 {
    1918                 :            :                                 al=SSL_AD_DECODE_ERROR;
    1919                 :            :                                 goto f_err;
    1920                 :            :                                 }
    1921                 :        605 :                         kn=EVP_PKEY_size(pkey);
    1922                 :            :                         }
    1923                 :            :                 else
    1924                 :            :                         {
    1925                 :            :                         pkey=NULL;
    1926                 :            :                         kn=0;
    1927                 :            :                         }
    1928                 :            : 
    1929         [ -  + ]:        737 :                 if (!BUF_MEM_grow_clean(buf,n+SSL_HM_HEADER_LENGTH(s)+kn))
    1930                 :            :                         {
    1931                 :          0 :                         SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_BUF);
    1932                 :          0 :                         goto err;
    1933                 :            :                         }
    1934                 :        737 :                 d = p = ssl_handshake_start(s);
    1935                 :            : 
    1936 [ +  + ][ +  + ]:       1485 :                 for (i=0; i < 4 && r[i] != NULL; i++)
    1937                 :            :                         {
    1938                 :            : #ifndef OPENSSL_NO_SRP
    1939 [ +  + ][ +  + ]:        748 :                         if ((i == 2) && (type & SSL_kSRP))
    1940                 :            :                                 {
    1941                 :         22 :                                 *p = nr[i];
    1942                 :         22 :                                 p++;
    1943                 :            :                                 }
    1944                 :            :                         else
    1945                 :            : #endif
    1946                 :        726 :                         s2n(nr[i],p);
    1947                 :        748 :                         BN_bn2bin(r[i],p);
    1948                 :        748 :                         p+=nr[i];
    1949                 :            :                         }
    1950                 :            : 
    1951                 :            : #ifndef OPENSSL_NO_ECDH
    1952         [ +  + ]:        737 :                 if (type & SSL_kECDHE) 
    1953                 :            :                         {
    1954                 :            :                         /* XXX: For now, we only support named (not generic) curves.
    1955                 :            :                          * In this situation, the serverKeyExchange message has:
    1956                 :            :                          * [1 byte CurveType], [2 byte CurveName]
    1957                 :            :                          * [1 byte length of encoded point], followed by
    1958                 :            :                          * the actual encoded point itself
    1959                 :            :                          */
    1960                 :        462 :                         *p = NAMED_CURVE_TYPE;
    1961                 :        462 :                         p += 1;
    1962                 :        462 :                         *p = 0;
    1963                 :        462 :                         p += 1;
    1964                 :        462 :                         *p = curve_id;
    1965                 :        462 :                         p += 1;
    1966                 :        462 :                         *p = encodedlen;
    1967                 :        462 :                         p += 1;
    1968                 :        462 :                         memcpy((unsigned char*)p, 
    1969                 :            :                             (unsigned char *)encodedPoint, 
    1970                 :            :                             encodedlen);
    1971                 :        462 :                         OPENSSL_free(encodedPoint);
    1972                 :        462 :                         encodedPoint = NULL;
    1973                 :        462 :                         p += encodedlen;
    1974                 :            :                         }
    1975                 :            : #endif
    1976                 :            : 
    1977                 :            : #ifndef OPENSSL_NO_PSK
    1978         [ +  + ]:        737 :                 if (type & SSL_kPSK)
    1979                 :            :                         {
    1980                 :            :                         /* copy PSK identity hint */
    1981                 :         22 :                         s2n(strlen(s->ctx->psk_identity_hint), p); 
    1982                 :         22 :                         strncpy((char *)p, s->ctx->psk_identity_hint, strlen(s->ctx->psk_identity_hint));
    1983                 :         22 :                         p+=strlen(s->ctx->psk_identity_hint);
    1984                 :            :                         }
    1985                 :            : #endif
    1986                 :            : 
    1987                 :            :                 /* not anonymous */
    1988         [ +  + ]:        737 :                 if (pkey != NULL)
    1989                 :            :                         {
    1990                 :            :                         /* n is the length of the params, they start at &(d[4])
    1991                 :            :                          * and p points to the space at the end. */
    1992                 :            : #ifndef OPENSSL_NO_RSA
    1993 [ +  - ][ +  + ]:        605 :                         if (pkey->type == EVP_PKEY_RSA && !SSL_USE_SIGALGS(s))
    1994                 :            :                                 {
    1995                 :            :                                 q=md_buf;
    1996                 :            :                                 j=0;
    1997         [ +  + ]:       1485 :                                 for (num=2; num > 0; num--)
    1998                 :            :                                         {
    1999                 :        990 :                                         EVP_MD_CTX_set_flags(&md_ctx,
    2000                 :            :                                                 EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
    2001         [ +  + ]:        990 :                                         EVP_DigestInit_ex(&md_ctx,(num == 2)
    2002                 :        990 :                                                 ?s->ctx->md5:s->ctx->sha1, NULL);
    2003                 :        990 :                                         EVP_DigestUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE);
    2004                 :        990 :                                         EVP_DigestUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE);
    2005                 :        990 :                                         EVP_DigestUpdate(&md_ctx,d,n);
    2006                 :        990 :                                         EVP_DigestFinal_ex(&md_ctx,q,
    2007                 :            :                                                 (unsigned int *)&i);
    2008                 :        990 :                                         q+=i;
    2009                 :        990 :                                         j+=i;
    2010                 :            :                                         }
    2011         [ -  + ]:        495 :                                 if (RSA_sign(NID_md5_sha1, md_buf, j,
    2012                 :        495 :                                         &(p[2]), &u, pkey->pkey.rsa) <= 0)
    2013                 :            :                                         {
    2014                 :          0 :                                         SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_RSA);
    2015                 :          0 :                                         goto err;
    2016                 :            :                                         }
    2017                 :        495 :                                 s2n(u,p);
    2018                 :        495 :                                 n+=u+2;
    2019                 :            :                                 }
    2020                 :            :                         else
    2021                 :            : #endif
    2022         [ +  - ]:        110 :                         if (md)
    2023                 :            :                                 {
    2024                 :            :                                 /* send signature algorithm */
    2025         [ +  - ]:        110 :                                 if (SSL_USE_SIGALGS(s))
    2026                 :            :                                         {
    2027         [ -  + ]:        110 :                                         if (!tls12_get_sigandhash(p, pkey, md))
    2028                 :            :                                                 {
    2029                 :            :                                                 /* Should never happen */
    2030                 :          0 :                                                 al=SSL_AD_INTERNAL_ERROR;
    2031                 :          0 :                                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
    2032                 :          0 :                                                 goto f_err;
    2033                 :            :                                                 }
    2034                 :        110 :                                         p+=2;
    2035                 :            :                                         }
    2036                 :            : #ifdef SSL_DEBUG
    2037                 :            :                                 fprintf(stderr, "Using hash %s\n",
    2038                 :            :                                                         EVP_MD_name(md));
    2039                 :            : #endif
    2040                 :        110 :                                 EVP_SignInit_ex(&md_ctx, md, NULL);
    2041                 :        110 :                                 EVP_SignUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE);
    2042                 :        110 :                                 EVP_SignUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE);
    2043                 :        110 :                                 EVP_SignUpdate(&md_ctx,d,n);
    2044         [ -  + ]:        110 :                                 if (!EVP_SignFinal(&md_ctx,&(p[2]),
    2045                 :            :                                         (unsigned int *)&i,pkey))
    2046                 :            :                                         {
    2047                 :          0 :                                         SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_EVP);
    2048                 :          0 :                                         goto err;
    2049                 :            :                                         }
    2050                 :        110 :                                 s2n(i,p);
    2051                 :        110 :                                 n+=i+2;
    2052         [ +  - ]:        110 :                                 if (SSL_USE_SIGALGS(s))
    2053                 :        110 :                                         n+= 2;
    2054                 :            :                                 }
    2055                 :            :                         else
    2056                 :            :                                 {
    2057                 :            :                                 /* Is this error check actually needed? */
    2058                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    2059                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_UNKNOWN_PKEY_TYPE);
    2060                 :          0 :                                 goto f_err;
    2061                 :            :                                 }
    2062                 :            :                         }
    2063                 :            : 
    2064                 :        737 :                 ssl_set_handshake_header(s, SSL3_MT_SERVER_KEY_EXCHANGE, n);
    2065                 :            :                 }
    2066                 :            : 
    2067                 :        737 :         s->state = SSL3_ST_SW_KEY_EXCH_B;
    2068                 :        737 :         EVP_MD_CTX_cleanup(&md_ctx);
    2069                 :        737 :         return ssl_do_write(s);
    2070                 :            : f_err:
    2071                 :          0 :         ssl3_send_alert(s,SSL3_AL_FATAL,al);
    2072                 :            : err:
    2073                 :            : #ifndef OPENSSL_NO_ECDH
    2074         [ #  # ]:          0 :         if (encodedPoint != NULL) OPENSSL_free(encodedPoint);
    2075                 :          0 :         BN_CTX_free(bn_ctx);
    2076                 :            : #endif
    2077                 :          0 :         EVP_MD_CTX_cleanup(&md_ctx);
    2078                 :          0 :         return(-1);
    2079                 :            :         }
    2080                 :            : 
    2081                 :         99 : int ssl3_send_certificate_request(SSL *s)
    2082                 :            :         {
    2083                 :            :         unsigned char *p,*d;
    2084                 :            :         int i,j,nl,off,n;
    2085                 :         99 :         STACK_OF(X509_NAME) *sk=NULL;
    2086                 :            :         X509_NAME *name;
    2087                 :            :         BUF_MEM *buf;
    2088                 :            : 
    2089         [ +  - ]:         99 :         if (s->state == SSL3_ST_SW_CERT_REQ_A)
    2090                 :            :                 {
    2091                 :         99 :                 buf=s->init_buf;
    2092                 :            : 
    2093                 :         99 :                 d=p=ssl_handshake_start(s);
    2094                 :            : 
    2095                 :            :                 /* get the list of acceptable cert types */
    2096                 :         99 :                 p++;
    2097                 :         99 :                 n=ssl3_get_req_cert_type(s,p);
    2098                 :         99 :                 d[0]=n;
    2099                 :         99 :                 p+=n;
    2100                 :         99 :                 n++;
    2101                 :            : 
    2102         [ +  + ]:         99 :                 if (SSL_USE_SIGALGS(s))
    2103                 :            :                         {
    2104                 :            :                         const unsigned char *psigs;
    2105                 :         55 :                         unsigned char *etmp = p;
    2106                 :         55 :                         nl = tls12_get_psigalgs(s, &psigs);
    2107                 :            :                         /* Skip over length for now */
    2108                 :         55 :                         p += 2;
    2109                 :         55 :                         nl = tls12_copy_sigalgs(s, p, psigs, nl);
    2110                 :            :                         /* Now fill in length */
    2111                 :         55 :                         s2n(nl, etmp);
    2112                 :         55 :                         p += nl;
    2113                 :         55 :                         n += nl + 2;
    2114                 :            :                         }
    2115                 :            : 
    2116                 :         99 :                 off=n;
    2117                 :         99 :                 p+=2;
    2118                 :         99 :                 n+=2;
    2119                 :            : 
    2120                 :         99 :                 sk=SSL_get_client_CA_list(s);
    2121                 :         99 :                 nl=0;
    2122         [ +  - ]:         99 :                 if (sk != NULL)
    2123                 :            :                         {
    2124         [ -  + ]:         99 :                         for (i=0; i<sk_X509_NAME_num(sk); i++)
    2125                 :            :                                 {
    2126                 :          0 :                                 name=sk_X509_NAME_value(sk,i);
    2127                 :          0 :                                 j=i2d_X509_NAME(name,NULL);
    2128         [ #  # ]:          0 :                                 if (!BUF_MEM_grow_clean(buf,SSL_HM_HEADER_LENGTH(s)+n+j+2))
    2129                 :            :                                         {
    2130                 :          0 :                                         SSLerr(SSL_F_SSL3_SEND_CERTIFICATE_REQUEST,ERR_R_BUF_LIB);
    2131                 :          0 :                                         goto err;
    2132                 :            :                                         }
    2133                 :          0 :                                 p = ssl_handshake_start(s) + n;
    2134         [ #  # ]:          0 :                                 if (!(s->options & SSL_OP_NETSCAPE_CA_DN_BUG))
    2135                 :            :                                         {
    2136                 :          0 :                                         s2n(j,p);
    2137                 :          0 :                                         i2d_X509_NAME(name,&p);
    2138                 :          0 :                                         n+=2+j;
    2139                 :          0 :                                         nl+=2+j;
    2140                 :            :                                         }
    2141                 :            :                                 else
    2142                 :            :                                         {
    2143                 :          0 :                                         d=p;
    2144                 :          0 :                                         i2d_X509_NAME(name,&p);
    2145                 :          0 :                                         j-=2; s2n(j,d); j+=2;
    2146                 :          0 :                                         n+=j;
    2147                 :          0 :                                         nl+=j;
    2148                 :            :                                         }
    2149                 :            :                                 }
    2150                 :            :                         }
    2151                 :            :                 /* else no CA names */
    2152                 :         99 :                 p = ssl_handshake_start(s) + off;
    2153                 :         99 :                 s2n(nl,p);
    2154                 :            : 
    2155                 :         99 :                 ssl_set_handshake_header(s, SSL3_MT_CERTIFICATE_REQUEST, n);
    2156                 :            : 
    2157                 :            : #ifdef NETSCAPE_HANG_BUG
    2158         [ +  - ]:         99 :                 if (!SSL_IS_DTLS(s))
    2159                 :            :                         {
    2160         [ -  + ]:         99 :                         if (!BUF_MEM_grow_clean(buf, s->init_num + 4))
    2161                 :            :                                 {
    2162                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_CERTIFICATE_REQUEST,ERR_R_BUF_LIB);
    2163                 :          0 :                                 goto err;
    2164                 :            :                                 }
    2165                 :         99 :                         p=(unsigned char *)s->init_buf->data + s->init_num;
    2166                 :            :                         /* do the header */
    2167                 :         99 :                         *(p++)=SSL3_MT_SERVER_DONE;
    2168                 :         99 :                         *(p++)=0;
    2169                 :         99 :                         *(p++)=0;
    2170                 :         99 :                         *(p++)=0;
    2171                 :         99 :                         s->init_num += 4;
    2172                 :            :                         }
    2173                 :            : #endif
    2174                 :            : 
    2175                 :         99 :                 s->state = SSL3_ST_SW_CERT_REQ_B;
    2176                 :            :                 }
    2177                 :            : 
    2178                 :            :         /* SSL3_ST_SW_CERT_REQ_B */
    2179                 :         99 :         return ssl_do_write(s);
    2180                 :            : err:
    2181                 :            :         return(-1);
    2182                 :            :         }
    2183                 :            : 
    2184                 :       1509 : int ssl3_get_client_key_exchange(SSL *s)
    2185                 :            :         {
    2186                 :            :         int i,al,ok;
    2187                 :            :         long n;
    2188                 :            :         unsigned long alg_k;
    2189                 :            :         unsigned char *p;
    2190                 :            : #ifndef OPENSSL_NO_RSA
    2191                 :       1509 :         RSA *rsa=NULL;
    2192                 :       1509 :         EVP_PKEY *pkey=NULL;
    2193                 :            : #endif
    2194                 :            : #ifndef OPENSSL_NO_DH
    2195                 :       1509 :         BIGNUM *pub=NULL;
    2196                 :       1509 :         DH *dh_srvr, *dh_clnt = NULL;
    2197                 :            : #endif
    2198                 :            : #ifndef OPENSSL_NO_KRB5
    2199                 :            :         KSSL_ERR kssl_err;
    2200                 :            : #endif /* OPENSSL_NO_KRB5 */
    2201                 :            : 
    2202                 :            : #ifndef OPENSSL_NO_ECDH
    2203                 :       1509 :         EC_KEY *srvr_ecdh = NULL;
    2204                 :       1509 :         EVP_PKEY *clnt_pub_pkey = NULL;
    2205                 :       1509 :         EC_POINT *clnt_ecpoint = NULL;
    2206                 :       1509 :         BN_CTX *bn_ctx = NULL; 
    2207                 :            : #endif
    2208                 :            : 
    2209                 :       1509 :         n=s->method->ssl_get_message(s,
    2210                 :            :                 SSL3_ST_SR_KEY_EXCH_A,
    2211                 :            :                 SSL3_ST_SR_KEY_EXCH_B,
    2212                 :            :                 SSL3_MT_CLIENT_KEY_EXCHANGE,
    2213                 :            :                 2048, /* ??? */
    2214                 :            :                 &ok);
    2215                 :            : 
    2216         [ +  + ]:       1509 :         if (!ok) return((int)n);
    2217                 :       1069 :         p=(unsigned char *)s->init_msg;
    2218                 :            : 
    2219                 :       1069 :         alg_k=s->s3->tmp.new_cipher->algorithm_mkey;
    2220                 :            : 
    2221                 :            : #ifndef OPENSSL_NO_RSA
    2222         [ +  + ]:       1069 :         if (alg_k & SSL_kRSA)
    2223                 :            :                 {
    2224                 :            :                 unsigned char rand_premaster_secret[SSL_MAX_MASTER_KEY_LENGTH];
    2225                 :            :                 int decrypt_len, decrypt_good_mask;
    2226                 :            :                 unsigned char version_good;
    2227                 :            : 
    2228                 :            :                 /* FIX THIS UP EAY EAY EAY EAY */
    2229         [ +  + ]:        365 :                 if (s->s3->tmp.use_rsa_tmp)
    2230                 :            :                         {
    2231 [ +  - ][ +  - ]:         33 :                         if ((s->cert != NULL) && (s->cert->rsa_tmp != NULL))
    2232                 :         33 :                                 rsa=s->cert->rsa_tmp;
    2233                 :            :                         /* Don't do a callback because rsa_tmp should
    2234                 :            :                          * be sent already */
    2235         [ -  + ]:         33 :                         if (rsa == NULL)
    2236                 :            :                                 {
    2237                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    2238                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_TMP_RSA_PKEY);
    2239                 :          0 :                                 goto f_err;
    2240                 :            : 
    2241                 :            :                                 }
    2242                 :            :                         }
    2243                 :            :                 else
    2244                 :            :                         {
    2245                 :        332 :                         pkey=s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey;
    2246 [ +  - ][ +  - ]:        332 :                         if (    (pkey == NULL) ||
    2247         [ -  + ]:        332 :                                 (pkey->type != EVP_PKEY_RSA) ||
    2248                 :        332 :                                 (pkey->pkey.rsa == NULL))
    2249                 :            :                                 {
    2250                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    2251                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_RSA_CERTIFICATE);
    2252                 :          0 :                                 goto f_err;
    2253                 :            :                                 }
    2254                 :            :                         rsa=pkey->pkey.rsa;
    2255                 :            :                         }
    2256                 :            : 
    2257                 :            :                 /* TLS and [incidentally] DTLS{0xFEFF} */
    2258         [ +  + ]:        365 :                 if (s->version > SSL3_VERSION && s->version != DTLS1_BAD_VER)
    2259                 :            :                         {
    2260                 :        200 :                         n2s(p,i);
    2261         [ -  + ]:        200 :                         if (n != i+2)
    2262                 :            :                                 {
    2263         [ #  # ]:          0 :                                 if (!(s->options & SSL_OP_TLS_D5_BUG))
    2264                 :            :                                         {
    2265                 :          0 :                                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG);
    2266                 :          0 :                                         goto err;
    2267                 :            :                                         }
    2268                 :            :                                 else
    2269                 :          0 :                                         p-=2;
    2270                 :            :                                 }
    2271                 :            :                         else
    2272                 :        200 :                                 n=i;
    2273                 :            :                         }
    2274                 :            : 
    2275                 :            :                 /* We must not leak whether a decryption failure occurs because
    2276                 :            :                  * of Bleichenbacher's attack on PKCS #1 v1.5 RSA padding (see
    2277                 :            :                  * RFC 2246, section 7.4.7.1). The code follows that advice of
    2278                 :            :                  * the TLS RFC and generates a random premaster secret for the
    2279                 :            :                  * case that the decrypt fails. See
    2280                 :            :                  * https://tools.ietf.org/html/rfc5246#section-7.4.7.1 */
    2281                 :            : 
    2282                 :            :                 /* should be RAND_bytes, but we cannot work around a failure. */
    2283         [ +  - ]:        365 :                 if (RAND_pseudo_bytes(rand_premaster_secret,
    2284                 :            :                                       sizeof(rand_premaster_secret)) <= 0)
    2285                 :            :                         goto err;
    2286                 :        365 :                 decrypt_len = RSA_private_decrypt((int)n,p,p,rsa,RSA_PKCS1_PADDING);
    2287                 :        365 :                 ERR_clear_error();
    2288                 :            : 
    2289                 :            :                 /* decrypt_len should be SSL_MAX_MASTER_KEY_LENGTH.
    2290                 :            :                  * decrypt_good_mask will be zero if so and non-zero otherwise. */
    2291                 :        365 :                 decrypt_good_mask = decrypt_len ^ SSL_MAX_MASTER_KEY_LENGTH;
    2292                 :            : 
    2293                 :            :                 /* If the version in the decrypted pre-master secret is correct
    2294                 :            :                  * then version_good will be zero. The Klima-Pokorny-Rosa
    2295                 :            :                  * extension of Bleichenbacher's attack
    2296                 :            :                  * (http://eprint.iacr.org/2003/052/) exploits the version
    2297                 :            :                  * number check as a "bad version oracle". Thus version checks
    2298                 :            :                  * are done in constant time and are treated like any other
    2299                 :            :                  * decryption error. */
    2300                 :        365 :                 version_good = p[0] ^ (s->client_version>>8);
    2301                 :        365 :                 version_good |= p[1] ^ (s->client_version&0xff);
    2302                 :            : 
    2303                 :            :                 /* The premaster secret must contain the same version number as
    2304                 :            :                  * the ClientHello to detect version rollback attacks
    2305                 :            :                  * (strangely, the protocol does not offer such protection for
    2306                 :            :                  * DH ciphersuites). However, buggy clients exist that send the
    2307                 :            :                  * negotiated protocol version instead if the server does not
    2308                 :            :                  * support the requested protocol version. If
    2309                 :            :                  * SSL_OP_TLS_ROLLBACK_BUG is set, tolerate such clients. */
    2310         [ -  + ]:        365 :                 if (s->options & SSL_OP_TLS_ROLLBACK_BUG)
    2311                 :            :                         {
    2312                 :          0 :                         unsigned char workaround_mask = version_good;
    2313                 :            :                         unsigned char workaround;
    2314                 :            : 
    2315                 :            :                         /* workaround_mask will be 0xff if version_good is
    2316                 :            :                          * non-zero (i.e. the version match failed). Otherwise
    2317                 :            :                          * it'll be 0x00. */
    2318                 :          0 :                         workaround_mask |= workaround_mask >> 4;
    2319                 :          0 :                         workaround_mask |= workaround_mask >> 2;
    2320                 :          0 :                         workaround_mask |= workaround_mask >> 1;
    2321                 :          0 :                         workaround_mask = ~((workaround_mask & 1) - 1);
    2322                 :            : 
    2323                 :          0 :                         workaround = p[0] ^ (s->version>>8);
    2324                 :          0 :                         workaround |= p[1] ^ (s->version&0xff);
    2325                 :            : 
    2326                 :            :                         /* If workaround_mask is 0xff (i.e. there was a version
    2327                 :            :                          * mismatch) then we copy the value of workaround over
    2328                 :            :                          * version_good. */
    2329                 :          0 :                         version_good = (workaround & workaround_mask) |
    2330                 :            :                                        (version_good & ~workaround_mask);
    2331                 :            :                         }
    2332                 :            : 
    2333                 :            :                 /* If any bits in version_good are set then they'll poision
    2334                 :            :                  * decrypt_good_mask and cause rand_premaster_secret to be
    2335                 :            :                  * used. */
    2336                 :        365 :                 decrypt_good_mask |= version_good;
    2337                 :            : 
    2338                 :            :                 /* decrypt_good_mask will be zero iff decrypt_len ==
    2339                 :            :                  * SSL_MAX_MASTER_KEY_LENGTH and the version check passed. We
    2340                 :            :                  * fold the bottom 32 bits of it with an OR so that the LSB
    2341                 :            :                  * will be zero iff everything is good. This assumes that we'll
    2342                 :            :                  * never decrypt a value > 2**31 bytes, which seems safe. */
    2343                 :        365 :                 decrypt_good_mask |= decrypt_good_mask >> 16;
    2344                 :        365 :                 decrypt_good_mask |= decrypt_good_mask >> 8;
    2345                 :        365 :                 decrypt_good_mask |= decrypt_good_mask >> 4;
    2346                 :        365 :                 decrypt_good_mask |= decrypt_good_mask >> 2;
    2347                 :        365 :                 decrypt_good_mask |= decrypt_good_mask >> 1;
    2348                 :            :                 /* Now select only the LSB and subtract one. If decrypt_len ==
    2349                 :            :                  * SSL_MAX_MASTER_KEY_LENGTH and the version check passed then
    2350                 :            :                  * decrypt_good_mask will be all ones. Otherwise it'll be all
    2351                 :            :                  * zeros. */
    2352                 :        365 :                 decrypt_good_mask &= 1;
    2353                 :        365 :                 decrypt_good_mask--;
    2354                 :            : 
    2355                 :            :                 /* Now copy rand_premaster_secret over p using
    2356                 :            :                  * decrypt_good_mask. */
    2357         [ +  + ]:      17885 :                 for (i = 0; i < (int) sizeof(rand_premaster_secret); i++)
    2358                 :            :                         {
    2359                 :      35040 :                         p[i] = (p[i] & decrypt_good_mask) |
    2360                 :      17520 :                                (rand_premaster_secret[i] & ~decrypt_good_mask);
    2361                 :            :                         }
    2362                 :            : 
    2363                 :        365 :                 s->session->master_key_length=
    2364                 :        365 :                         s->method->ssl3_enc->generate_master_secret(s,
    2365                 :        365 :                                 s->session->master_key,
    2366                 :            :                                 p,i);
    2367                 :        365 :                 OPENSSL_cleanse(p,i);
    2368                 :            :                 }
    2369                 :            :         else
    2370                 :            : #endif
    2371                 :            : #ifndef OPENSSL_NO_DH
    2372         [ +  + ]:        704 :                 if (alg_k & (SSL_kDHE|SSL_kDHr|SSL_kDHd))
    2373                 :            :                 {
    2374                 :        198 :                 int idx = -1;
    2375                 :        198 :                 EVP_PKEY *skey = NULL;
    2376         [ +  - ]:        198 :                 if (n)
    2377                 :        198 :                         n2s(p,i);
    2378                 :            :                 else
    2379                 :            :                         i = 0;
    2380 [ +  - ][ -  + ]:        198 :                 if (n && n != i+2)
    2381                 :            :                         {
    2382         [ #  # ]:          0 :                         if (!(s->options & SSL_OP_SSLEAY_080_CLIENT_DH_BUG))
    2383                 :            :                                 {
    2384                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG);
    2385                 :          0 :                                 goto err;
    2386                 :            :                                 }
    2387                 :            :                         else
    2388                 :            :                                 {
    2389                 :          0 :                                 p-=2;
    2390                 :          0 :                                 i=(int)n;
    2391                 :            :                                 }
    2392                 :            :                         }
    2393         [ +  - ]:        198 :                 if (alg_k & SSL_kDHr)
    2394                 :            :                         idx = SSL_PKEY_DH_RSA;
    2395         [ -  + ]:        198 :                 else if (alg_k & SSL_kDHd)
    2396                 :          0 :                         idx = SSL_PKEY_DH_DSA;
    2397         [ -  + ]:        198 :                 if (idx >= 0)
    2398                 :            :                         {
    2399                 :          0 :                         skey = s->cert->pkeys[idx].privatekey;
    2400 [ #  # ][ #  # ]:          0 :                         if ((skey == NULL) ||
    2401         [ #  # ]:          0 :                                 (skey->type != EVP_PKEY_DH) ||
    2402                 :          0 :                                 (skey->pkey.dh == NULL))
    2403                 :            :                                 {
    2404                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    2405                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_RSA_CERTIFICATE);
    2406                 :          0 :                                 goto f_err;
    2407                 :            :                                 }
    2408                 :            :                         dh_srvr = skey->pkey.dh;
    2409                 :            :                         }
    2410         [ -  + ]:        198 :                 else if (s->s3->tmp.dh == NULL)
    2411                 :            :                         {
    2412                 :          0 :                         al=SSL_AD_HANDSHAKE_FAILURE;
    2413                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_TMP_DH_KEY);
    2414                 :          0 :                         goto f_err;
    2415                 :            :                         }
    2416                 :            :                 else
    2417                 :            :                         dh_srvr=s->s3->tmp.dh;
    2418                 :            : 
    2419         [ -  + ]:        198 :                 if (n == 0L)
    2420                 :            :                         {
    2421                 :            :                         /* Get pubkey from cert */
    2422                 :          0 :                         EVP_PKEY *clkey=X509_get_pubkey(s->session->peer);
    2423         [ #  # ]:          0 :                         if (clkey)
    2424                 :            :                                 {
    2425         [ #  # ]:          0 :                                 if (EVP_PKEY_cmp_parameters(clkey, skey) == 1)
    2426                 :          0 :                                         dh_clnt = EVP_PKEY_get1_DH(clkey);
    2427                 :            :                                 }
    2428         [ #  # ]:          0 :                         if (dh_clnt == NULL)
    2429                 :            :                                 {
    2430                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    2431                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_TMP_DH_KEY);
    2432                 :          0 :                                 goto f_err;
    2433                 :            :                                 }
    2434                 :          0 :                         EVP_PKEY_free(clkey);
    2435                 :          0 :                         pub = dh_clnt->pub_key;
    2436                 :            :                         }
    2437                 :            :                 else
    2438                 :        198 :                         pub=BN_bin2bn(p,i,NULL);
    2439         [ -  + ]:        198 :                 if (pub == NULL)
    2440                 :            :                         {
    2441                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_BN_LIB);
    2442                 :          0 :                         goto err;
    2443                 :            :                         }
    2444                 :            : 
    2445                 :        198 :                 i=DH_compute_key(p,pub,dh_srvr);
    2446                 :            : 
    2447         [ -  + ]:        198 :                 if (i <= 0)
    2448                 :            :                         {
    2449                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,ERR_R_DH_LIB);
    2450                 :          0 :                         BN_clear_free(pub);
    2451                 :          0 :                         goto err;
    2452                 :            :                         }
    2453                 :            : 
    2454                 :        198 :                 DH_free(s->s3->tmp.dh);
    2455                 :        198 :                 s->s3->tmp.dh=NULL;
    2456         [ -  + ]:        198 :                 if (dh_clnt)
    2457                 :          0 :                         DH_free(dh_clnt);
    2458                 :            :                 else
    2459                 :        198 :                         BN_clear_free(pub);
    2460                 :        198 :                 pub=NULL;
    2461                 :        198 :                 s->session->master_key_length=
    2462                 :        198 :                         s->method->ssl3_enc->generate_master_secret(s,
    2463                 :        198 :                                 s->session->master_key,p,i);
    2464                 :        198 :                 OPENSSL_cleanse(p,i);
    2465         [ +  - ]:        198 :                 if (dh_clnt)
    2466                 :            :                         return 2;
    2467                 :            :                 }
    2468                 :            :         else
    2469                 :            : #endif
    2470                 :            : #ifndef OPENSSL_NO_KRB5
    2471                 :            :         if (alg_k & SSL_kKRB5)
    2472                 :            :                 {
    2473                 :            :                 krb5_error_code         krb5rc;
    2474                 :            :                 krb5_data               enc_ticket;
    2475                 :            :                 krb5_data               authenticator;
    2476                 :            :                 krb5_data               enc_pms;
    2477                 :            :                 KSSL_CTX                *kssl_ctx = s->kssl_ctx;
    2478                 :            :                 EVP_CIPHER_CTX          ciph_ctx;
    2479                 :            :                 const EVP_CIPHER        *enc = NULL;
    2480                 :            :                 unsigned char           iv[EVP_MAX_IV_LENGTH];
    2481                 :            :                 unsigned char           pms[SSL_MAX_MASTER_KEY_LENGTH
    2482                 :            :                                                + EVP_MAX_BLOCK_LENGTH];
    2483                 :            :                 int                  padl, outl;
    2484                 :            :                 krb5_timestamp          authtime = 0;
    2485                 :            :                 krb5_ticket_times       ttimes;
    2486                 :            : 
    2487                 :            :                 EVP_CIPHER_CTX_init(&ciph_ctx);
    2488                 :            : 
    2489                 :            :                 if (!kssl_ctx)  kssl_ctx = kssl_ctx_new();
    2490                 :            : 
    2491                 :            :                 n2s(p,i);
    2492                 :            :                 enc_ticket.length = i;
    2493                 :            : 
    2494                 :            :                 if (n < (long)(enc_ticket.length + 6))
    2495                 :            :                         {
    2496                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2497                 :            :                                 SSL_R_DATA_LENGTH_TOO_LONG);
    2498                 :            :                         goto err;
    2499                 :            :                         }
    2500                 :            : 
    2501                 :            :                 enc_ticket.data = (char *)p;
    2502                 :            :                 p+=enc_ticket.length;
    2503                 :            : 
    2504                 :            :                 n2s(p,i);
    2505                 :            :                 authenticator.length = i;
    2506                 :            : 
    2507                 :            :                 if (n < (long)(enc_ticket.length + authenticator.length + 6))
    2508                 :            :                         {
    2509                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2510                 :            :                                 SSL_R_DATA_LENGTH_TOO_LONG);
    2511                 :            :                         goto err;
    2512                 :            :                         }
    2513                 :            : 
    2514                 :            :                 authenticator.data = (char *)p;
    2515                 :            :                 p+=authenticator.length;
    2516                 :            : 
    2517                 :            :                 n2s(p,i);
    2518                 :            :                 enc_pms.length = i;
    2519                 :            :                 enc_pms.data = (char *)p;
    2520                 :            :                 p+=enc_pms.length;
    2521                 :            : 
    2522                 :            :                 /* Note that the length is checked again below,
    2523                 :            :                 ** after decryption
    2524                 :            :                 */
    2525                 :            :                 if(enc_pms.length > sizeof pms)
    2526                 :            :                         {
    2527                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2528                 :            :                                SSL_R_DATA_LENGTH_TOO_LONG);
    2529                 :            :                         goto err;
    2530                 :            :                         }
    2531                 :            : 
    2532                 :            :                 if (n != (long)(enc_ticket.length + authenticator.length +
    2533                 :            :                                                 enc_pms.length + 6))
    2534                 :            :                         {
    2535                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2536                 :            :                                 SSL_R_DATA_LENGTH_TOO_LONG);
    2537                 :            :                         goto err;
    2538                 :            :                         }
    2539                 :            : 
    2540                 :            :                 if ((krb5rc = kssl_sget_tkt(kssl_ctx, &enc_ticket, &ttimes,
    2541                 :            :                                         &kssl_err)) != 0)
    2542                 :            :                         {
    2543                 :            : #ifdef KSSL_DEBUG
    2544                 :            :                         printf("kssl_sget_tkt rtn %d [%d]\n",
    2545                 :            :                                 krb5rc, kssl_err.reason);
    2546                 :            :                         if (kssl_err.text)
    2547                 :            :                                 printf("kssl_err text= %s\n", kssl_err.text);
    2548                 :            : #endif  /* KSSL_DEBUG */
    2549                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2550                 :            :                                 kssl_err.reason);
    2551                 :            :                         goto err;
    2552                 :            :                         }
    2553                 :            : 
    2554                 :            :                 /*  Note: no authenticator is not considered an error,
    2555                 :            :                 **  but will return authtime == 0.
    2556                 :            :                 */
    2557                 :            :                 if ((krb5rc = kssl_check_authent(kssl_ctx, &authenticator,
    2558                 :            :                                         &authtime, &kssl_err)) != 0)
    2559                 :            :                         {
    2560                 :            : #ifdef KSSL_DEBUG
    2561                 :            :                         printf("kssl_check_authent rtn %d [%d]\n",
    2562                 :            :                                 krb5rc, kssl_err.reason);
    2563                 :            :                         if (kssl_err.text)
    2564                 :            :                                 printf("kssl_err text= %s\n", kssl_err.text);
    2565                 :            : #endif  /* KSSL_DEBUG */
    2566                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2567                 :            :                                 kssl_err.reason);
    2568                 :            :                         goto err;
    2569                 :            :                         }
    2570                 :            : 
    2571                 :            :                 if ((krb5rc = kssl_validate_times(authtime, &ttimes)) != 0)
    2572                 :            :                         {
    2573                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, krb5rc);
    2574                 :            :                         goto err;
    2575                 :            :                         }
    2576                 :            : 
    2577                 :            : #ifdef KSSL_DEBUG
    2578                 :            :                 kssl_ctx_show(kssl_ctx);
    2579                 :            : #endif  /* KSSL_DEBUG */
    2580                 :            : 
    2581                 :            :                 enc = kssl_map_enc(kssl_ctx->enctype);
    2582                 :            :                 if (enc == NULL)
    2583                 :            :                     goto err;
    2584                 :            : 
    2585                 :            :                 memset(iv, 0, sizeof iv);       /* per RFC 1510 */
    2586                 :            : 
    2587                 :            :                 if (!EVP_DecryptInit_ex(&ciph_ctx,enc,NULL,kssl_ctx->key,iv))
    2588                 :            :                         {
    2589                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2590                 :            :                                 SSL_R_DECRYPTION_FAILED);
    2591                 :            :                         goto err;
    2592                 :            :                         }
    2593                 :            :                 if (!EVP_DecryptUpdate(&ciph_ctx, pms,&outl,
    2594                 :            :                                         (unsigned char *)enc_pms.data, enc_pms.length))
    2595                 :            :                         {
    2596                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2597                 :            :                                 SSL_R_DECRYPTION_FAILED);
    2598                 :            :                         goto err;
    2599                 :            :                         }
    2600                 :            :                 if (outl > SSL_MAX_MASTER_KEY_LENGTH)
    2601                 :            :                         {
    2602                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2603                 :            :                                 SSL_R_DATA_LENGTH_TOO_LONG);
    2604                 :            :                         goto err;
    2605                 :            :                         }
    2606                 :            :                 if (!EVP_DecryptFinal_ex(&ciph_ctx,&(pms[outl]),&padl))
    2607                 :            :                         {
    2608                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2609                 :            :                                 SSL_R_DECRYPTION_FAILED);
    2610                 :            :                         goto err;
    2611                 :            :                         }
    2612                 :            :                 outl += padl;
    2613                 :            :                 if (outl > SSL_MAX_MASTER_KEY_LENGTH)
    2614                 :            :                         {
    2615                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2616                 :            :                                 SSL_R_DATA_LENGTH_TOO_LONG);
    2617                 :            :                         goto err;
    2618                 :            :                         }
    2619                 :            :                 if (!((pms[0] == (s->client_version>>8)) && (pms[1] == (s->client_version & 0xff))))
    2620                 :            :                     {
    2621                 :            :                     /* The premaster secret must contain the same version number as the
    2622                 :            :                      * ClientHello to detect version rollback attacks (strangely, the
    2623                 :            :                      * protocol does not offer such protection for DH ciphersuites).
    2624                 :            :                      * However, buggy clients exist that send random bytes instead of
    2625                 :            :                      * the protocol version.
    2626                 :            :                      * If SSL_OP_TLS_ROLLBACK_BUG is set, tolerate such clients. 
    2627                 :            :                      * (Perhaps we should have a separate BUG value for the Kerberos cipher)
    2628                 :            :                      */
    2629                 :            :                     if (!(s->options & SSL_OP_TLS_ROLLBACK_BUG))
    2630                 :            :                         {
    2631                 :            :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2632                 :            :                                SSL_AD_DECODE_ERROR);
    2633                 :            :                         goto err;
    2634                 :            :                         }
    2635                 :            :                     }
    2636                 :            : 
    2637                 :            :                 EVP_CIPHER_CTX_cleanup(&ciph_ctx);
    2638                 :            : 
    2639                 :            :                 s->session->master_key_length=
    2640                 :            :                         s->method->ssl3_enc->generate_master_secret(s,
    2641                 :            :                                 s->session->master_key, pms, outl);
    2642                 :            : 
    2643                 :            :                 if (kssl_ctx->client_princ)
    2644                 :            :                         {
    2645                 :            :                         size_t len = strlen(kssl_ctx->client_princ);
    2646                 :            :                         if ( len < SSL_MAX_KRB5_PRINCIPAL_LENGTH ) 
    2647                 :            :                                 {
    2648                 :            :                                 s->session->krb5_client_princ_len = len;
    2649                 :            :                                 memcpy(s->session->krb5_client_princ,kssl_ctx->client_princ,len);
    2650                 :            :                                 }
    2651                 :            :                         }
    2652                 :            : 
    2653                 :            : 
    2654                 :            :                 /*  Was doing kssl_ctx_free() here,
    2655                 :            :                 **  but it caused problems for apache.
    2656                 :            :                 **  kssl_ctx = kssl_ctx_free(kssl_ctx);
    2657                 :            :                 **  if (s->kssl_ctx)  s->kssl_ctx = NULL;
    2658                 :            :                 */
    2659                 :            :                 }
    2660                 :            :         else
    2661                 :            : #endif  /* OPENSSL_NO_KRB5 */
    2662                 :            : 
    2663                 :            : #ifndef OPENSSL_NO_ECDH
    2664         [ +  + ]:        506 :                 if (alg_k & (SSL_kECDHE|SSL_kECDHr|SSL_kECDHe))
    2665                 :            :                 {
    2666                 :        462 :                 int ret = 1;
    2667                 :        462 :                 int field_size = 0;
    2668                 :            :                 const EC_KEY   *tkey;
    2669                 :            :                 const EC_GROUP *group;
    2670                 :            :                 const BIGNUM *priv_key;
    2671                 :            : 
    2672                 :            :                 /* initialize structures for server's ECDH key pair */
    2673         [ -  + ]:        462 :                 if ((srvr_ecdh = EC_KEY_new()) == NULL) 
    2674                 :            :                         {
    2675                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2676                 :            :                             ERR_R_MALLOC_FAILURE);
    2677                 :          0 :                         goto err;
    2678                 :            :                         }
    2679                 :            : 
    2680                 :            :                 /* Let's get server private key and group information */
    2681         [ -  + ]:        462 :                 if (alg_k & (SSL_kECDHr|SSL_kECDHe))
    2682                 :            :                         { 
    2683                 :            :                         /* use the certificate */
    2684                 :          0 :                         tkey = s->cert->pkeys[SSL_PKEY_ECC].privatekey->pkey.ec;
    2685                 :            :                         }
    2686                 :            :                 else
    2687                 :            :                         {
    2688                 :            :                         /* use the ephermeral values we saved when
    2689                 :            :                          * generating the ServerKeyExchange msg.
    2690                 :            :                          */
    2691                 :        462 :                         tkey = s->s3->tmp.ecdh;
    2692                 :            :                         }
    2693                 :            : 
    2694                 :        462 :                 group    = EC_KEY_get0_group(tkey);
    2695                 :        462 :                 priv_key = EC_KEY_get0_private_key(tkey);
    2696                 :            : 
    2697   [ +  -  -  + ]:        924 :                 if (!EC_KEY_set_group(srvr_ecdh, group) ||
    2698                 :        462 :                     !EC_KEY_set_private_key(srvr_ecdh, priv_key))
    2699                 :            :                         {
    2700                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2701                 :            :                                ERR_R_EC_LIB);
    2702                 :          0 :                         goto err;
    2703                 :            :                         }
    2704                 :            : 
    2705                 :            :                 /* Let's get client's public key */
    2706         [ -  + ]:        462 :                 if ((clnt_ecpoint = EC_POINT_new(group)) == NULL)
    2707                 :            :                         {
    2708                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2709                 :            :                             ERR_R_MALLOC_FAILURE);
    2710                 :          0 :                         goto err;
    2711                 :            :                         }
    2712                 :            : 
    2713         [ -  + ]:        462 :                 if (n == 0L) 
    2714                 :            :                         {
    2715                 :            :                         /* Client Publickey was in Client Certificate */
    2716                 :            : 
    2717         [ #  # ]:          0 :                          if (alg_k & SSL_kECDHE)
    2718                 :            :                                  {
    2719                 :          0 :                                  al=SSL_AD_HANDSHAKE_FAILURE;
    2720                 :          0 :                                  SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_TMP_ECDH_KEY);
    2721                 :          0 :                                  goto f_err;
    2722                 :            :                                  }
    2723         [ #  # ]:          0 :                         if (((clnt_pub_pkey=X509_get_pubkey(s->session->peer))
    2724         [ #  # ]:          0 :                             == NULL) || 
    2725                 :          0 :                             (clnt_pub_pkey->type != EVP_PKEY_EC))
    2726                 :            :                                 {
    2727                 :            :                                 /* XXX: For now, we do not support client
    2728                 :            :                                  * authentication using ECDH certificates
    2729                 :            :                                  * so this branch (n == 0L) of the code is
    2730                 :            :                                  * never executed. When that support is
    2731                 :            :                                  * added, we ought to ensure the key 
    2732                 :            :                                  * received in the certificate is 
    2733                 :            :                                  * authorized for key agreement.
    2734                 :            :                                  * ECDH_compute_key implicitly checks that
    2735                 :            :                                  * the two ECDH shares are for the same
    2736                 :            :                                  * group.
    2737                 :            :                                  */
    2738                 :          0 :                                 al=SSL_AD_HANDSHAKE_FAILURE;
    2739                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2740                 :            :                                     SSL_R_UNABLE_TO_DECODE_ECDH_CERTS);
    2741                 :          0 :                                 goto f_err;
    2742                 :            :                                 }
    2743                 :            : 
    2744         [ #  # ]:          0 :                         if (EC_POINT_copy(clnt_ecpoint,
    2745                 :          0 :                             EC_KEY_get0_public_key(clnt_pub_pkey->pkey.ec)) == 0)
    2746                 :            :                                 {
    2747                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2748                 :            :                                         ERR_R_EC_LIB);
    2749                 :          0 :                                 goto err;
    2750                 :            :                                 }
    2751                 :            :                         ret = 2; /* Skip certificate verify processing */
    2752                 :            :                         }
    2753                 :            :                 else
    2754                 :            :                         {
    2755                 :            :                         /* Get client's public key from encoded point
    2756                 :            :                          * in the ClientKeyExchange message.
    2757                 :            :                          */
    2758         [ -  + ]:        462 :                         if ((bn_ctx = BN_CTX_new()) == NULL)
    2759                 :            :                                 {
    2760                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2761                 :            :                                     ERR_R_MALLOC_FAILURE);
    2762                 :          0 :                                 goto err;
    2763                 :            :                                 }
    2764                 :            : 
    2765                 :            :                         /* Get encoded point length */
    2766                 :        462 :                         i = *p; 
    2767                 :        462 :                         p += 1;
    2768         [ -  + ]:        462 :                         if (n != 1 + i)
    2769                 :            :                                 {
    2770                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2771                 :            :                                     ERR_R_EC_LIB);
    2772                 :          0 :                                 goto err;
    2773                 :            :                                 }
    2774         [ -  + ]:        462 :                         if (EC_POINT_oct2point(group, 
    2775                 :            :                             clnt_ecpoint, p, i, bn_ctx) == 0)
    2776                 :            :                                 {
    2777                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2778                 :            :                                     ERR_R_EC_LIB);
    2779                 :          0 :                                 goto err;
    2780                 :            :                                 }
    2781                 :            :                         /* p is pointing to somewhere in the buffer
    2782                 :            :                          * currently, so set it to the start 
    2783                 :            :                          */ 
    2784                 :        462 :                         p=(unsigned char *)s->init_buf->data;
    2785                 :            :                         }
    2786                 :            : 
    2787                 :            :                 /* Compute the shared pre-master secret */
    2788                 :        462 :                 field_size = EC_GROUP_get_degree(group);
    2789         [ -  + ]:        462 :                 if (field_size <= 0)
    2790                 :            :                         {
    2791                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, 
    2792                 :            :                                ERR_R_ECDH_LIB);
    2793                 :          0 :                         goto err;
    2794                 :            :                         }
    2795                 :        462 :                 i = ECDH_compute_key(p, (field_size+7)/8, clnt_ecpoint, srvr_ecdh, NULL);
    2796         [ -  + ]:        462 :                 if (i <= 0)
    2797                 :            :                         {
    2798                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2799                 :            :                             ERR_R_ECDH_LIB);
    2800                 :          0 :                         goto err;
    2801                 :            :                         }
    2802                 :            : 
    2803                 :        462 :                 EVP_PKEY_free(clnt_pub_pkey);
    2804                 :        462 :                 EC_POINT_free(clnt_ecpoint);
    2805                 :        462 :                 EC_KEY_free(srvr_ecdh);
    2806                 :        462 :                 BN_CTX_free(bn_ctx);
    2807                 :        462 :                 EC_KEY_free(s->s3->tmp.ecdh);
    2808                 :        462 :                 s->s3->tmp.ecdh = NULL; 
    2809                 :            : 
    2810                 :            :                 /* Compute the master secret */
    2811                 :        924 :                 s->session->master_key_length = s->method->ssl3_enc-> \
    2812                 :        462 :                     generate_master_secret(s, s->session->master_key, p, i);
    2813                 :            :                 
    2814                 :        462 :                 OPENSSL_cleanse(p, i);
    2815                 :        462 :                 return (ret);
    2816                 :            :                 }
    2817                 :            :         else
    2818                 :            : #endif
    2819                 :            : #ifndef OPENSSL_NO_PSK
    2820         [ +  + ]:         44 :                 if (alg_k & SSL_kPSK)
    2821                 :            :                         {
    2822                 :         22 :                         unsigned char *t = NULL;
    2823                 :            :                         unsigned char psk_or_pre_ms[PSK_MAX_PSK_LEN*2+4];
    2824                 :         22 :                         unsigned int pre_ms_len = 0, psk_len = 0;
    2825                 :         22 :                         int psk_err = 1;
    2826                 :            :                         char tmp_id[PSK_MAX_IDENTITY_LEN+1];
    2827                 :            : 
    2828                 :         22 :                         al=SSL_AD_HANDSHAKE_FAILURE;
    2829                 :            : 
    2830                 :         22 :                         n2s(p,i);
    2831         [ -  + ]:         22 :                         if (n != i+2)
    2832                 :            :                                 {
    2833                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2834                 :            :                                         SSL_R_LENGTH_MISMATCH);
    2835                 :          0 :                                 goto psk_err;
    2836                 :            :                                 }
    2837         [ -  + ]:         22 :                         if (i > PSK_MAX_IDENTITY_LEN)
    2838                 :            :                                 {
    2839                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2840                 :            :                                         SSL_R_DATA_LENGTH_TOO_LONG);
    2841                 :          0 :                                 goto psk_err;
    2842                 :            :                                 }
    2843         [ -  + ]:         22 :                         if (s->psk_server_callback == NULL)
    2844                 :            :                                 {
    2845                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2846                 :            :                                        SSL_R_PSK_NO_SERVER_CB);
    2847                 :          0 :                                 goto psk_err;
    2848                 :            :                                 }
    2849                 :            : 
    2850                 :            :                         /* Create guaranteed NULL-terminated identity
    2851                 :            :                          * string for the callback */
    2852                 :         22 :                         memcpy(tmp_id, p, i);
    2853                 :         22 :                         memset(tmp_id+i, 0, PSK_MAX_IDENTITY_LEN+1-i);
    2854                 :         22 :                         psk_len = s->psk_server_callback(s, tmp_id,
    2855                 :            :                                 psk_or_pre_ms, sizeof(psk_or_pre_ms));
    2856                 :         22 :                         OPENSSL_cleanse(tmp_id, PSK_MAX_IDENTITY_LEN+1);
    2857                 :            : 
    2858         [ -  + ]:         22 :                         if (psk_len > PSK_MAX_PSK_LEN)
    2859                 :            :                                 {
    2860                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2861                 :            :                                         ERR_R_INTERNAL_ERROR);
    2862                 :          0 :                                 goto psk_err;
    2863                 :            :                                 }
    2864         [ -  + ]:         22 :                         else if (psk_len == 0)
    2865                 :            :                                 {
    2866                 :            :                                 /* PSK related to the given identity not found */
    2867                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2868                 :            :                                        SSL_R_PSK_IDENTITY_NOT_FOUND);
    2869                 :          0 :                                 al=SSL_AD_UNKNOWN_PSK_IDENTITY;
    2870                 :          0 :                                 goto psk_err;
    2871                 :            :                                 }
    2872                 :            : 
    2873                 :            :                         /* create PSK pre_master_secret */
    2874                 :         22 :                         pre_ms_len=2+psk_len+2+psk_len;
    2875                 :         22 :                         t = psk_or_pre_ms;
    2876                 :         22 :                         memmove(psk_or_pre_ms+psk_len+4, psk_or_pre_ms, psk_len);
    2877                 :         22 :                         s2n(psk_len, t);
    2878                 :         22 :                         memset(t, 0, psk_len);
    2879                 :         22 :                         t+=psk_len;
    2880                 :         22 :                         s2n(psk_len, t);
    2881                 :            : 
    2882         [ -  + ]:         22 :                         if (s->session->psk_identity != NULL)
    2883                 :          0 :                                 OPENSSL_free(s->session->psk_identity);
    2884                 :         22 :                         s->session->psk_identity = BUF_strdup((char *)p);
    2885         [ -  + ]:         22 :                         if (s->session->psk_identity == NULL)
    2886                 :            :                                 {
    2887                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2888                 :            :                                         ERR_R_MALLOC_FAILURE);
    2889                 :          0 :                                 goto psk_err;
    2890                 :            :                                 }
    2891                 :            : 
    2892         [ -  + ]:         22 :                         if (s->session->psk_identity_hint != NULL)
    2893                 :          0 :                                 OPENSSL_free(s->session->psk_identity_hint);
    2894                 :         22 :                         s->session->psk_identity_hint = BUF_strdup(s->ctx->psk_identity_hint);
    2895 [ +  - ][ -  + ]:         22 :                         if (s->ctx->psk_identity_hint != NULL &&
    2896                 :         22 :                                 s->session->psk_identity_hint == NULL)
    2897                 :            :                                 {
    2898                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2899                 :            :                                         ERR_R_MALLOC_FAILURE);
    2900                 :          0 :                                 goto psk_err;
    2901                 :            :                                 }
    2902                 :            : 
    2903                 :         22 :                         s->session->master_key_length=
    2904                 :         22 :                                 s->method->ssl3_enc->generate_master_secret(s,
    2905                 :         22 :                                         s->session->master_key, psk_or_pre_ms, pre_ms_len);
    2906                 :         22 :                         psk_err = 0;
    2907                 :            :                 psk_err:
    2908                 :         22 :                         OPENSSL_cleanse(psk_or_pre_ms, sizeof(psk_or_pre_ms));
    2909         [ +  - ]:         22 :                         if (psk_err != 0)
    2910                 :            :                                 goto f_err;
    2911                 :            :                         }
    2912                 :            :                 else
    2913                 :            : #endif
    2914                 :            : #ifndef OPENSSL_NO_SRP
    2915         [ +  - ]:         22 :                 if (alg_k & SSL_kSRP)
    2916                 :            :                         {
    2917                 :            :                         int param_len;
    2918                 :            : 
    2919                 :         22 :                         n2s(p,i);
    2920                 :         22 :                         param_len=i+2;
    2921         [ -  + ]:         22 :                         if (param_len > n)
    2922                 :            :                                 {
    2923                 :          0 :                                 al=SSL_AD_DECODE_ERROR;
    2924                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_BAD_SRP_A_LENGTH);
    2925                 :          0 :                                 goto f_err;
    2926                 :            :                                 }
    2927         [ -  + ]:         22 :                         if (!(s->srp_ctx.A=BN_bin2bn(p,i,NULL)))
    2928                 :            :                                 {
    2929                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,ERR_R_BN_LIB);
    2930                 :          0 :                                 goto err;
    2931                 :            :                                 }
    2932         [ -  + ]:         22 :                         if (s->session->srp_username != NULL)
    2933                 :          0 :                                 OPENSSL_free(s->session->srp_username);
    2934                 :         22 :                         s->session->srp_username = BUF_strdup(s->srp_ctx.login);
    2935         [ -  + ]:         22 :                         if (s->session->srp_username == NULL)
    2936                 :            :                                 {
    2937                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    2938                 :            :                                         ERR_R_MALLOC_FAILURE);
    2939                 :          0 :                                 goto err;
    2940                 :            :                                 }
    2941                 :            : 
    2942         [ -  + ]:         22 :                         if ((s->session->master_key_length = SRP_generate_server_master_secret(s,s->session->master_key))<0)
    2943                 :            :                                 {
    2944                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
    2945                 :          0 :                                 goto err;
    2946                 :            :                                 }
    2947                 :            : 
    2948                 :            :                         p+=i;
    2949                 :            :                         }
    2950                 :            :                 else
    2951                 :            : #endif  /* OPENSSL_NO_SRP */
    2952         [ #  # ]:          0 :                 if (alg_k & SSL_kGOST) 
    2953                 :            :                         {
    2954                 :          0 :                         int ret = 0;
    2955                 :            :                         EVP_PKEY_CTX *pkey_ctx;
    2956                 :          0 :                         EVP_PKEY *client_pub_pkey = NULL, *pk = NULL;
    2957                 :            :                         unsigned char premaster_secret[32], *start;
    2958                 :          0 :                         size_t outlen=32, inlen;
    2959                 :            :                         unsigned long alg_a;
    2960                 :            :                         int Ttag, Tclass;
    2961                 :            :                         long Tlen;
    2962                 :            : 
    2963                 :            :                         /* Get our certificate private key*/
    2964                 :          0 :                         alg_a = s->s3->tmp.new_cipher->algorithm_auth;
    2965         [ #  # ]:          0 :                         if (alg_a & SSL_aGOST94)
    2966                 :          0 :                                 pk = s->cert->pkeys[SSL_PKEY_GOST94].privatekey;
    2967         [ #  # ]:          0 :                         else if (alg_a & SSL_aGOST01)
    2968                 :          0 :                                 pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
    2969                 :            : 
    2970                 :          0 :                         pkey_ctx = EVP_PKEY_CTX_new(pk,NULL);
    2971                 :          0 :                         EVP_PKEY_decrypt_init(pkey_ctx);
    2972                 :            :                         /* If client certificate is present and is of the same type, maybe
    2973                 :            :                          * use it for key exchange.  Don't mind errors from
    2974                 :            :                          * EVP_PKEY_derive_set_peer, because it is completely valid to use
    2975                 :            :                          * a client certificate for authorization only. */
    2976                 :          0 :                         client_pub_pkey = X509_get_pubkey(s->session->peer);
    2977         [ #  # ]:          0 :                         if (client_pub_pkey)
    2978                 :            :                                 {
    2979         [ #  # ]:          0 :                                 if (EVP_PKEY_derive_set_peer(pkey_ctx, client_pub_pkey) <= 0)
    2980                 :          0 :                                         ERR_clear_error();
    2981                 :            :                                 }
    2982                 :            :                         /* Decrypt session key */
    2983 [ #  # ][ #  # ]:          0 :                         if (ASN1_get_object((const unsigned char **)&p, &Tlen, &Ttag, &Tclass, n) != V_ASN1_CONSTRUCTED || 
    2984         [ #  # ]:          0 :                                 Ttag != V_ASN1_SEQUENCE ||
    2985                 :          0 :                                 Tclass != V_ASN1_UNIVERSAL) 
    2986                 :            :                                 {
    2987                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_DECRYPTION_FAILED);
    2988                 :          0 :                                 goto gerr;
    2989                 :            :                                 }
    2990                 :          0 :                         start = p;
    2991                 :          0 :                         inlen = Tlen;
    2992         [ #  # ]:          0 :                         if (EVP_PKEY_decrypt(pkey_ctx,premaster_secret,&outlen,start,inlen) <=0) 
    2993                 :            : 
    2994                 :            :                                 {
    2995                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_DECRYPTION_FAILED);
    2996                 :          0 :                                 goto gerr;
    2997                 :            :                                 }
    2998                 :            :                         /* Generate master secret */
    2999                 :          0 :                         s->session->master_key_length=
    3000                 :          0 :                                 s->method->ssl3_enc->generate_master_secret(s,
    3001                 :          0 :                                         s->session->master_key,premaster_secret,32);
    3002                 :            :                         /* Check if pubkey from client certificate was used */
    3003         [ #  # ]:          0 :                         if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2, NULL) > 0)
    3004                 :            :                                 ret = 2;
    3005                 :            :                         else
    3006                 :          0 :                                 ret = 1;
    3007                 :            :                 gerr:
    3008                 :          0 :                         EVP_PKEY_free(client_pub_pkey);
    3009                 :          0 :                         EVP_PKEY_CTX_free(pkey_ctx);
    3010         [ #  # ]:          0 :                         if (ret)
    3011                 :          0 :                                 return ret;
    3012                 :            :                         else
    3013                 :            :                                 goto err;
    3014                 :            :                         }
    3015                 :            :                 else
    3016                 :            :                 {
    3017                 :          0 :                 al=SSL_AD_HANDSHAKE_FAILURE;
    3018                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
    3019                 :            :                                 SSL_R_UNKNOWN_CIPHER_TYPE);
    3020                 :        198 :                 goto f_err;
    3021                 :            :                 }
    3022                 :            : 
    3023                 :            :         return(1);
    3024                 :            : f_err:
    3025                 :          0 :         ssl3_send_alert(s,SSL3_AL_FATAL,al);
    3026                 :            : #if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_ECDH) || defined(OPENSSL_NO_SRP)
    3027                 :            : err:
    3028                 :            : #endif
    3029                 :            : #ifndef OPENSSL_NO_ECDH
    3030                 :          0 :         EVP_PKEY_free(clnt_pub_pkey);
    3031                 :          0 :         EC_POINT_free(clnt_ecpoint);
    3032         [ #  # ]:          0 :         if (srvr_ecdh != NULL) 
    3033                 :          0 :                 EC_KEY_free(srvr_ecdh);
    3034                 :          0 :         BN_CTX_free(bn_ctx);
    3035                 :            : #endif
    3036                 :          0 :         return(-1);
    3037                 :            :         }
    3038                 :            : 
    3039                 :      10595 : int ssl3_get_cert_verify(SSL *s)
    3040                 :            :         {
    3041                 :      10595 :         EVP_PKEY *pkey=NULL;
    3042                 :            :         unsigned char *p;
    3043                 :      10595 :         int al,ok,ret=0;
    3044                 :            :         long n;
    3045                 :      10595 :         int type=0,i,j;
    3046                 :            :         X509 *peer;
    3047                 :      10595 :         const EVP_MD *md = NULL;
    3048                 :            :         EVP_MD_CTX mctx;
    3049                 :      10595 :         EVP_MD_CTX_init(&mctx);
    3050                 :            : 
    3051                 :      10595 :         n=s->method->ssl_get_message(s,
    3052                 :            :                 SSL3_ST_SR_CERT_VRFY_A,
    3053                 :            :                 SSL3_ST_SR_CERT_VRFY_B,
    3054                 :            :                 -1,
    3055                 :            :                 SSL3_RT_MAX_PLAIN_LENGTH,
    3056                 :            :                 &ok);
    3057                 :            : 
    3058         [ +  + ]:      10595 :         if (!ok) return((int)n);
    3059                 :            : 
    3060         [ +  + ]:       1069 :         if (s->session->peer != NULL)
    3061                 :            :                 {
    3062                 :         99 :                 peer=s->session->peer;
    3063                 :         99 :                 pkey=X509_get_pubkey(peer);
    3064                 :         99 :                 type=X509_certificate_type(peer,pkey);
    3065                 :            :                 }
    3066                 :            :         else
    3067                 :            :                 {
    3068                 :            :                 peer=NULL;
    3069                 :            :                 pkey=NULL;
    3070                 :            :                 }
    3071                 :            : 
    3072         [ +  + ]:       1069 :         if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE_VERIFY)
    3073                 :            :                 {
    3074                 :        970 :                 s->s3->tmp.reuse_message=1;
    3075 [ -  + ][ #  # ]:        970 :                 if ((peer != NULL) && (type & EVP_PKT_SIGN))
    3076                 :            :                         {
    3077                 :          0 :                         al=SSL_AD_UNEXPECTED_MESSAGE;
    3078                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_MISSING_VERIFY_MESSAGE);
    3079                 :          0 :                         goto f_err;
    3080                 :            :                         }
    3081                 :            :                 ret=1;
    3082                 :            :                 goto end;
    3083                 :            :                 }
    3084                 :            : 
    3085         [ -  + ]:         99 :         if (peer == NULL)
    3086                 :            :                 {
    3087                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_NO_CLIENT_CERT_RECEIVED);
    3088                 :          0 :                 al=SSL_AD_UNEXPECTED_MESSAGE;
    3089                 :          0 :                 goto f_err;
    3090                 :            :                 }
    3091                 :            : 
    3092         [ -  + ]:         99 :         if (!(type & EVP_PKT_SIGN))
    3093                 :            :                 {
    3094                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
    3095                 :          0 :                 al=SSL_AD_ILLEGAL_PARAMETER;
    3096                 :          0 :                 goto f_err;
    3097                 :            :                 }
    3098                 :            : 
    3099         [ -  + ]:         99 :         if (s->s3->change_cipher_spec)
    3100                 :            :                 {
    3101                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_CCS_RECEIVED_EARLY);
    3102                 :          0 :                 al=SSL_AD_UNEXPECTED_MESSAGE;
    3103                 :          0 :                 goto f_err;
    3104                 :            :                 }
    3105                 :            : 
    3106                 :            :         /* we now have a signature that we need to verify */
    3107                 :         99 :         p=(unsigned char *)s->init_msg;
    3108                 :            :         /* Check for broken implementations of GOST ciphersuites */
    3109                 :            :         /* If key is GOST and n is exactly 64, it is bare
    3110                 :            :          * signature without length field */
    3111 [ -  + ][ #  # ]:         99 :         if (n==64 && (pkey->type==NID_id_GostR3410_94 ||
    3112                 :            :                 pkey->type == NID_id_GostR3410_2001) )
    3113                 :            :                 {
    3114                 :            :                 i=64;
    3115                 :            :                 } 
    3116                 :            :         else 
    3117                 :            :                 {       
    3118         [ +  + ]:         99 :                 if (SSL_USE_SIGALGS(s))
    3119                 :            :                         {
    3120                 :         55 :                         int rv = tls12_check_peer_sigalg(&md, s, p, pkey);
    3121         [ +  - ]:         55 :                         if (rv == -1)
    3122                 :            :                                 {
    3123                 :            :                                 al = SSL_AD_INTERNAL_ERROR;
    3124                 :            :                                 goto f_err;
    3125                 :            :                                 }
    3126         [ +  - ]:         55 :                         else if (rv == 0)
    3127                 :            :                                 {
    3128                 :            :                                 al = SSL_AD_DECODE_ERROR;
    3129                 :            :                                 goto f_err;
    3130                 :            :                                 }
    3131                 :            : #ifdef SSL_DEBUG
    3132                 :            : fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
    3133                 :            : #endif
    3134                 :         55 :                         p += 2;
    3135                 :         55 :                         n -= 2;
    3136                 :            :                         }
    3137                 :         99 :                 n2s(p,i);
    3138                 :         99 :                 n-=2;
    3139         [ -  + ]:         99 :                 if (i > n)
    3140                 :            :                         {
    3141                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_LENGTH_MISMATCH);
    3142                 :          0 :                         al=SSL_AD_DECODE_ERROR;
    3143                 :          0 :                         goto f_err;
    3144                 :            :                         }
    3145                 :            :         }
    3146                 :         99 :         j=EVP_PKEY_size(pkey);
    3147 [ +  - ][ +  - ]:         99 :         if ((i > j) || (n > j) || (n <= 0))
                 [ -  + ]
    3148                 :            :                 {
    3149                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_WRONG_SIGNATURE_SIZE);
    3150                 :          0 :                 al=SSL_AD_DECODE_ERROR;
    3151                 :          0 :                 goto f_err;
    3152                 :            :                 }
    3153                 :            : 
    3154         [ +  + ]:         99 :         if (SSL_USE_SIGALGS(s))
    3155                 :            :                 {
    3156                 :         55 :                 long hdatalen = 0;
    3157                 :            :                 void *hdata;
    3158                 :         55 :                 hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
    3159         [ -  + ]:         55 :                 if (hdatalen <= 0)
    3160                 :            :                         {
    3161                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
    3162                 :          0 :                         al=SSL_AD_INTERNAL_ERROR;
    3163                 :          0 :                         goto f_err;
    3164                 :            :                         }
    3165                 :            : #ifdef SSL_DEBUG
    3166                 :            :                 fprintf(stderr, "Using TLS 1.2 with client verify alg %s\n",
    3167                 :            :                                                         EVP_MD_name(md));
    3168                 :            : #endif
    3169         [ +  - ]:         55 :                 if (!EVP_VerifyInit_ex(&mctx, md, NULL)
    3170         [ -  + ]:         55 :                         || !EVP_VerifyUpdate(&mctx, hdata, hdatalen))
    3171                 :            :                         {
    3172                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, ERR_R_EVP_LIB);
    3173                 :          0 :                         al=SSL_AD_INTERNAL_ERROR;
    3174                 :          0 :                         goto f_err;
    3175                 :            :                         }
    3176                 :            : 
    3177         [ -  + ]:         55 :                 if (EVP_VerifyFinal(&mctx, p , i, pkey) <= 0)
    3178                 :            :                         {
    3179                 :          0 :                         al=SSL_AD_DECRYPT_ERROR;
    3180                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_BAD_SIGNATURE);
    3181                 :         55 :                         goto f_err;
    3182                 :            :                         }
    3183                 :            :                 }
    3184                 :            :         else
    3185                 :            : #ifndef OPENSSL_NO_RSA 
    3186         [ +  - ]:         44 :         if (pkey->type == EVP_PKEY_RSA)
    3187                 :            :                 {
    3188                 :         44 :                 i=RSA_verify(NID_md5_sha1, s->s3->tmp.cert_verify_md,
    3189                 :            :                         MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH, p, i, 
    3190                 :         44 :                                                         pkey->pkey.rsa);
    3191         [ -  + ]:         44 :                 if (i < 0)
    3192                 :            :                         {
    3193                 :          0 :                         al=SSL_AD_DECRYPT_ERROR;
    3194                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_BAD_RSA_DECRYPT);
    3195                 :          0 :                         goto f_err;
    3196                 :            :                         }
    3197         [ -  + ]:         44 :                 if (i == 0)
    3198                 :            :                         {
    3199                 :          0 :                         al=SSL_AD_DECRYPT_ERROR;
    3200                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_BAD_RSA_SIGNATURE);
    3201                 :          0 :                         goto f_err;
    3202                 :            :                         }
    3203                 :            :                 }
    3204                 :            :         else
    3205                 :            : #endif
    3206                 :            : #ifndef OPENSSL_NO_DSA
    3207         [ #  # ]:          0 :                 if (pkey->type == EVP_PKEY_DSA)
    3208                 :            :                 {
    3209                 :          0 :                 j=DSA_verify(pkey->save_type,
    3210                 :          0 :                         &(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
    3211                 :          0 :                         SHA_DIGEST_LENGTH,p,i,pkey->pkey.dsa);
    3212         [ #  # ]:          0 :                 if (j <= 0)
    3213                 :            :                         {
    3214                 :            :                         /* bad signature */
    3215                 :          0 :                         al=SSL_AD_DECRYPT_ERROR;
    3216                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_BAD_DSA_SIGNATURE);
    3217                 :          0 :                         goto f_err;
    3218                 :            :                         }
    3219                 :            :                 }
    3220                 :            :         else
    3221                 :            : #endif
    3222                 :            : #ifndef OPENSSL_NO_ECDSA
    3223         [ #  # ]:          0 :                 if (pkey->type == EVP_PKEY_EC)
    3224                 :            :                 {
    3225                 :          0 :                 j=ECDSA_verify(pkey->save_type,
    3226                 :          0 :                         &(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
    3227                 :          0 :                         SHA_DIGEST_LENGTH,p,i,pkey->pkey.ec);
    3228         [ #  # ]:          0 :                 if (j <= 0)
    3229                 :            :                         {
    3230                 :            :                         /* bad signature */
    3231                 :          0 :                         al=SSL_AD_DECRYPT_ERROR;
    3232                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,
    3233                 :            :                             SSL_R_BAD_ECDSA_SIGNATURE);
    3234                 :          0 :                         goto f_err;
    3235                 :            :                         }
    3236                 :            :                 }
    3237                 :            :         else
    3238                 :            : #endif
    3239         [ #  # ]:          0 :         if (pkey->type == NID_id_GostR3410_94 || pkey->type == NID_id_GostR3410_2001)
    3240                 :            :                 {   unsigned char signature[64];
    3241                 :            :                         int idx;
    3242                 :          0 :                         EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new(pkey,NULL);
    3243                 :          0 :                         EVP_PKEY_verify_init(pctx);
    3244         [ #  # ]:          0 :                         if (i!=64) {
    3245                 :          0 :                                 fprintf(stderr,"GOST signature length is %d",i);
    3246                 :            :                         }       
    3247         [ #  # ]:          0 :                         for (idx=0;idx<64;idx++) {
    3248                 :          0 :                                 signature[63-idx]=p[idx];
    3249                 :            :                         }       
    3250                 :          0 :                         j=EVP_PKEY_verify(pctx,signature,64,s->s3->tmp.cert_verify_md,32);
    3251                 :          0 :                         EVP_PKEY_CTX_free(pctx);
    3252         [ #  # ]:          0 :                         if (j<=0) 
    3253                 :            :                                 {
    3254                 :          0 :                                 al=SSL_AD_DECRYPT_ERROR;
    3255                 :          0 :                                 SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,
    3256                 :            :                                         SSL_R_BAD_ECDSA_SIGNATURE);
    3257                 :          0 :                                 goto f_err;
    3258                 :            :                                 }       
    3259                 :            :                 }
    3260                 :            :         else    
    3261                 :            :                 {
    3262                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,ERR_R_INTERNAL_ERROR);
    3263                 :          0 :                 al=SSL_AD_UNSUPPORTED_CERTIFICATE;
    3264                 :          0 :                 goto f_err;
    3265                 :            :                 }
    3266                 :            : 
    3267                 :            : 
    3268                 :            :         ret=1;
    3269                 :            :         if (0)
    3270                 :            :                 {
    3271                 :            : f_err:
    3272                 :          0 :                 ssl3_send_alert(s,SSL3_AL_FATAL,al);
    3273                 :            :                 }
    3274                 :            : end:
    3275         [ +  + ]:       1069 :         if (s->s3->handshake_buffer)
    3276                 :            :                 {
    3277                 :         55 :                 BIO_free(s->s3->handshake_buffer);
    3278                 :         55 :                 s->s3->handshake_buffer = NULL;
    3279                 :         55 :                 s->s3->flags &= ~TLS1_FLAGS_KEEP_HANDSHAKE;
    3280                 :            :                 }
    3281                 :       1069 :         EVP_MD_CTX_cleanup(&mctx);
    3282                 :       1069 :         EVP_PKEY_free(pkey);
    3283                 :       1069 :         return(ret);
    3284                 :            :         }
    3285                 :            : 
    3286                 :         99 : int ssl3_get_client_certificate(SSL *s)
    3287                 :            :         {
    3288                 :         99 :         int i,ok,al,ret= -1;
    3289                 :         99 :         X509 *x=NULL;
    3290                 :            :         unsigned long l,nc,llen,n;
    3291                 :            :         const unsigned char *p,*q;
    3292                 :            :         unsigned char *d;
    3293                 :         99 :         STACK_OF(X509) *sk=NULL;
    3294                 :            : 
    3295                 :         99 :         n=s->method->ssl_get_message(s,
    3296                 :            :                 SSL3_ST_SR_CERT_A,
    3297                 :            :                 SSL3_ST_SR_CERT_B,
    3298                 :            :                 -1,
    3299                 :            :                 s->max_cert_list,
    3300                 :            :                 &ok);
    3301                 :            : 
    3302         [ -  + ]:         99 :         if (!ok) return((int)n);
    3303                 :            : 
    3304         [ -  + ]:         99 :         if      (s->s3->tmp.message_type == SSL3_MT_CLIENT_KEY_EXCHANGE)
    3305                 :            :                 {
    3306         [ #  # ]:          0 :                 if (    (s->verify_mode & SSL_VERIFY_PEER) &&
    3307                 :            :                         (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT))
    3308                 :            :                         {
    3309                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
    3310                 :          0 :                         al=SSL_AD_HANDSHAKE_FAILURE;
    3311                 :          0 :                         goto f_err;
    3312                 :            :                         }
    3313                 :            :                 /* If tls asked for a client cert, the client must return a 0 list */
    3314 [ #  # ][ #  # ]:          0 :                 if ((s->version > SSL3_VERSION) && s->s3->tmp.cert_request)
    3315                 :            :                         {
    3316                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST);
    3317                 :          0 :                         al=SSL_AD_UNEXPECTED_MESSAGE;
    3318                 :          0 :                         goto f_err;
    3319                 :            :                         }
    3320                 :          0 :                 s->s3->tmp.reuse_message=1;
    3321                 :          0 :                 return(1);
    3322                 :            :                 }
    3323                 :            : 
    3324         [ -  + ]:         99 :         if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE)
    3325                 :            :                 {
    3326                 :          0 :                 al=SSL_AD_UNEXPECTED_MESSAGE;
    3327                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_WRONG_MESSAGE_TYPE);
    3328                 :          0 :                 goto f_err;
    3329                 :            :                 }
    3330                 :         99 :         p=d=(unsigned char *)s->init_msg;
    3331                 :            : 
    3332         [ -  + ]:         99 :         if ((sk=sk_X509_new_null()) == NULL)
    3333                 :            :                 {
    3334                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,ERR_R_MALLOC_FAILURE);
    3335                 :          0 :                 goto err;
    3336                 :            :                 }
    3337                 :            : 
    3338                 :         99 :         n2l3(p,llen);
    3339         [ +  - ]:         99 :         if (llen+3 != n)
    3340                 :            :                 {
    3341                 :          0 :                 al=SSL_AD_DECODE_ERROR;
    3342                 :          0 :                 SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_LENGTH_MISMATCH);
    3343                 :          0 :                 goto f_err;
    3344                 :            :                 }
    3345         [ +  + ]:        423 :         for (nc=0; nc<llen; )
    3346                 :            :                 {
    3347                 :        324 :                 n2l3(p,l);
    3348         [ -  + ]:        324 :                 if ((l+nc+3) > llen)
    3349                 :            :                         {
    3350                 :          0 :                         al=SSL_AD_DECODE_ERROR;
    3351                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_CERT_LENGTH_MISMATCH);
    3352                 :          0 :                         goto f_err;
    3353                 :            :                         }
    3354                 :            : 
    3355                 :        324 :                 q=p;
    3356                 :        324 :                 x=d2i_X509(NULL,&p,l);
    3357         [ -  + ]:        324 :                 if (x == NULL)
    3358                 :            :                         {
    3359                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,ERR_R_ASN1_LIB);
    3360                 :          0 :                         goto err;
    3361                 :            :                         }
    3362         [ -  + ]:        324 :                 if (p != (q+l))
    3363                 :            :                         {
    3364                 :          0 :                         al=SSL_AD_DECODE_ERROR;
    3365                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_CERT_LENGTH_MISMATCH);
    3366                 :          0 :                         goto f_err;
    3367                 :            :                         }
    3368         [ -  + ]:        324 :                 if (!sk_X509_push(sk,x))
    3369                 :            :                         {
    3370                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,ERR_R_MALLOC_FAILURE);
    3371                 :        324 :                         goto err;
    3372                 :            :                         }
    3373                 :            :                 x=NULL;
    3374                 :            :                 nc+=l+3;
    3375                 :            :                 }
    3376                 :            : 
    3377         [ -  + ]:         99 :         if (sk_X509_num(sk) <= 0)
    3378                 :            :                 {
    3379                 :            :                 /* TLS does not mind 0 certs returned */
    3380         [ #  # ]:          0 :                 if (s->version == SSL3_VERSION)
    3381                 :            :                         {
    3382                 :          0 :                         al=SSL_AD_HANDSHAKE_FAILURE;
    3383                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_NO_CERTIFICATES_RETURNED);
    3384                 :          0 :                         goto f_err;
    3385                 :            :                         }
    3386                 :            :                 /* Fail for TLS only if we required a certificate */
    3387         [ #  # ]:          0 :                 else if ((s->verify_mode & SSL_VERIFY_PEER) &&
    3388                 :            :                          (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT))
    3389                 :            :                         {
    3390                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
    3391                 :          0 :                         al=SSL_AD_HANDSHAKE_FAILURE;
    3392                 :          0 :                         goto f_err;
    3393                 :            :                         }
    3394                 :            :                 /* No client certificate so digest cached records */
    3395 [ #  # ][ #  # ]:          0 :                 if (s->s3->handshake_buffer && !ssl3_digest_cached_records(s))
    3396                 :            :                         {
    3397                 :            :                         al=SSL_AD_INTERNAL_ERROR;
    3398                 :            :                         goto f_err;
    3399                 :            :                         }
    3400                 :            :                 }
    3401                 :            :         else
    3402                 :            :                 {
    3403                 :            :                 EVP_PKEY *pkey;
    3404                 :         99 :                 i=ssl_verify_cert_chain(s,sk);
    3405         [ -  + ]:         99 :                 if (i <= 0)
    3406                 :            :                         {
    3407                 :          0 :                         al=ssl_verify_alarm_type(s->verify_result);
    3408                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_CERTIFICATE_VERIFY_FAILED);
    3409                 :          0 :                         goto f_err;
    3410                 :            :                         }
    3411         [ -  + ]:         99 :                 if (i > 1)
    3412                 :            :                         {
    3413                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, i);
    3414                 :          0 :                         al = SSL_AD_HANDSHAKE_FAILURE;
    3415                 :          0 :                         goto f_err;
    3416                 :            :                         }
    3417                 :         99 :                 pkey = X509_get_pubkey(sk_X509_value(sk, 0));
    3418         [ -  + ]:         99 :                 if (pkey == NULL)
    3419                 :            :                         {
    3420                 :          0 :                         al=SSL3_AD_HANDSHAKE_FAILURE;
    3421                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
    3422                 :            :                                                 SSL_R_UNKNOWN_CERTIFICATE_TYPE);
    3423                 :          0 :                         goto f_err;
    3424                 :            :                         }
    3425                 :         99 :                 EVP_PKEY_free(pkey);
    3426                 :            :                 }
    3427                 :            : 
    3428         [ -  + ]:         99 :         if (s->session->peer != NULL) /* This should not be needed */
    3429                 :          0 :                 X509_free(s->session->peer);
    3430                 :         99 :         s->session->peer=sk_X509_shift(sk);
    3431                 :         99 :         s->session->verify_result = s->verify_result;
    3432                 :            : 
    3433                 :            :         /* With the current implementation, sess_cert will always be NULL
    3434                 :            :          * when we arrive here. */
    3435         [ +  - ]:         99 :         if (s->session->sess_cert == NULL)
    3436                 :            :                 {
    3437                 :         99 :                 s->session->sess_cert = ssl_sess_cert_new();
    3438         [ -  + ]:         99 :                 if (s->session->sess_cert == NULL)
    3439                 :            :                         {
    3440                 :          0 :                         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
    3441                 :          0 :                         goto err;
    3442                 :            :                         }
    3443                 :            :                 }
    3444         [ -  + ]:         99 :         if (s->session->sess_cert->cert_chain != NULL)
    3445                 :          0 :                 sk_X509_pop_free(s->session->sess_cert->cert_chain, X509_free);
    3446                 :         99 :         s->session->sess_cert->cert_chain=sk;
    3447                 :            :         /* Inconsistency alert: cert_chain does *not* include the
    3448                 :            :          * peer's own certificate, while we do include it in s3_clnt.c */
    3449                 :            : 
    3450                 :         99 :         sk=NULL;
    3451                 :            : 
    3452                 :         99 :         ret=1;
    3453                 :            :         if (0)
    3454                 :            :                 {
    3455                 :            : f_err:
    3456                 :          0 :                 ssl3_send_alert(s,SSL3_AL_FATAL,al);
    3457                 :            :                 }
    3458                 :            : err:
    3459         [ -  + ]:         99 :         if (x != NULL) X509_free(x);
    3460         [ -  + ]:         99 :         if (sk != NULL) sk_X509_pop_free(sk,X509_free);
    3461                 :         99 :         return(ret);
    3462                 :            :         }
    3463                 :            : 
    3464                 :        937 : int ssl3_send_server_certificate(SSL *s)
    3465                 :            :         {
    3466                 :            :         CERT_PKEY *cpk;
    3467                 :            : 
    3468         [ +  - ]:        937 :         if (s->state == SSL3_ST_SW_CERT_A)
    3469                 :            :                 {
    3470                 :        937 :                 cpk=ssl_get_server_send_pkey(s);
    3471         [ -  + ]:        937 :                 if (cpk == NULL)
    3472                 :            :                         {
    3473                 :            :                         /* VRS: allow null cert if auth == KRB5 */
    3474 [ #  # ][ #  # ]:          0 :                         if ((s->s3->tmp.new_cipher->algorithm_auth != SSL_aKRB5) ||
    3475                 :          0 :                             (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kKRB5))
    3476                 :            :                                 {
    3477                 :          0 :                                 SSLerr(SSL_F_SSL3_SEND_SERVER_CERTIFICATE,ERR_R_INTERNAL_ERROR);
    3478                 :          0 :                                 return(0);
    3479                 :            :                                 }
    3480                 :            :                         }
    3481                 :            : 
    3482         [ -  + ]:        937 :                 if (!ssl3_output_cert_chain(s,cpk))
    3483                 :            :                         {
    3484                 :          0 :                         SSLerr(SSL_F_SSL3_SEND_SERVER_CERTIFICATE,ERR_R_INTERNAL_ERROR);
    3485                 :          0 :                         return(0);
    3486                 :            :                         }
    3487                 :        937 :                 s->state=SSL3_ST_SW_CERT_B;
    3488                 :            :                 }
    3489                 :            : 
    3490                 :            :         /* SSL3_ST_SW_CERT_B */
    3491                 :        937 :         return ssl_do_write(s);
    3492                 :            :         }
    3493                 :            : 
    3494                 :            : #ifndef OPENSSL_NO_TLSEXT
    3495                 :            : /* send a new session ticket (not necessarily for a new session) */
    3496                 :        816 : int ssl3_send_newsession_ticket(SSL *s)
    3497                 :            :         {
    3498         [ +  - ]:        816 :         if (s->state == SSL3_ST_SW_SESSION_TICKET_A)
    3499                 :            :                 {
    3500                 :            :                 unsigned char *p, *senc, *macstart;
    3501                 :            :                 const unsigned char *const_p;
    3502                 :            :                 int len, slen_full, slen;
    3503                 :            :                 SSL_SESSION *sess;
    3504                 :            :                 unsigned int hlen;
    3505                 :            :                 EVP_CIPHER_CTX ctx;
    3506                 :            :                 HMAC_CTX hctx;
    3507                 :        816 :                 SSL_CTX *tctx = s->initial_ctx;
    3508                 :            :                 unsigned char iv[EVP_MAX_IV_LENGTH];
    3509                 :            :                 unsigned char key_name[16];
    3510                 :            : 
    3511                 :            :                 /* get session encoding length */
    3512                 :        816 :                 slen_full = i2d_SSL_SESSION(s->session, NULL);
    3513                 :            :                 /* Some length values are 16 bits, so forget it if session is
    3514                 :            :                  * too long
    3515                 :            :                  */
    3516         [ +  - ]:        816 :                 if (slen_full > 0xFF00)
    3517                 :          0 :                         return -1;
    3518                 :        816 :                 senc = OPENSSL_malloc(slen_full);
    3519         [ +  - ]:        816 :                 if (!senc)
    3520                 :            :                         return -1;
    3521                 :        816 :                 p = senc;
    3522                 :        816 :                 i2d_SSL_SESSION(s->session, &p);
    3523                 :            : 
    3524                 :            :                 /* create a fresh copy (not shared with other threads) to clean up */
    3525                 :        816 :                 const_p = senc;
    3526                 :        816 :                 sess = d2i_SSL_SESSION(NULL, &const_p, slen_full);
    3527         [ -  + ]:        816 :                 if (sess == NULL)
    3528                 :            :                         {
    3529                 :          0 :                         OPENSSL_free(senc);
    3530                 :          0 :                         return -1;
    3531                 :            :                         }
    3532                 :        816 :                 sess->session_id_length = 0; /* ID is irrelevant for the ticket */
    3533                 :            : 
    3534                 :        816 :                 slen = i2d_SSL_SESSION(sess, NULL);
    3535         [ -  + ]:        816 :                 if (slen > slen_full) /* shouldn't ever happen */
    3536                 :            :                         {
    3537                 :          0 :                         OPENSSL_free(senc);
    3538                 :          0 :                         return -1;
    3539                 :            :                         }
    3540                 :        816 :                 p = senc;
    3541                 :        816 :                 i2d_SSL_SESSION(sess, &p);
    3542                 :        816 :                 SSL_SESSION_free(sess);
    3543                 :            : 
    3544                 :            :                 /* Grow buffer if need be: the length calculation is as
    3545                 :            :                  * follows handshake_header_length +
    3546                 :            :                  * 4 (ticket lifetime hint) + 2 (ticket length) +
    3547                 :            :                  * 16 (key name) + max_iv_len (iv length) +
    3548                 :            :                  * session_length + max_enc_block_size (max encrypted session
    3549                 :            :                  * length) + max_md_size (HMAC).
    3550                 :            :                  */
    3551         [ +  - ]:        816 :                 if (!BUF_MEM_grow(s->init_buf,
    3552                 :        816 :                         SSL_HM_HEADER_LENGTH(s) + 22 + EVP_MAX_IV_LENGTH +
    3553                 :        816 :                         EVP_MAX_BLOCK_LENGTH + EVP_MAX_MD_SIZE + slen))
    3554                 :            :                         return -1;
    3555                 :        816 :                 p = ssl_handshake_start(s);
    3556                 :        816 :                 EVP_CIPHER_CTX_init(&ctx);
    3557                 :        816 :                 HMAC_CTX_init(&hctx);
    3558                 :            :                 /* Initialize HMAC and cipher contexts. If callback present
    3559                 :            :                  * it does all the work otherwise use generated values
    3560                 :            :                  * from parent ctx.
    3561                 :            :                  */
    3562         [ -  + ]:        816 :                 if (tctx->tlsext_ticket_key_cb)
    3563                 :            :                         {
    3564         [ #  # ]:          0 :                         if (tctx->tlsext_ticket_key_cb(s, key_name, iv, &ctx,
    3565                 :            :                                                          &hctx, 1) < 0)
    3566                 :            :                                 {
    3567                 :          0 :                                 OPENSSL_free(senc);
    3568                 :          0 :                                 return -1;
    3569                 :            :                                 }
    3570                 :            :                         }
    3571                 :            :                 else
    3572                 :            :                         {
    3573                 :        816 :                         RAND_pseudo_bytes(iv, 16);
    3574                 :        816 :                         EVP_EncryptInit_ex(&ctx, EVP_aes_128_cbc(), NULL,
    3575                 :        816 :                                         tctx->tlsext_tick_aes_key, iv);
    3576                 :        816 :                         HMAC_Init_ex(&hctx, tctx->tlsext_tick_hmac_key, 16,
    3577                 :            :                                         tlsext_tick_md(), NULL);
    3578                 :        816 :                         memcpy(key_name, tctx->tlsext_tick_key_name, 16);
    3579                 :            :                         }
    3580                 :            : 
    3581                 :            :                 /* Ticket lifetime hint (advisory only):
    3582                 :            :                  * We leave this unspecified for resumed session (for simplicity),
    3583                 :            :                  * and guess that tickets for new sessions will live as long
    3584                 :            :                  * as their sessions. */
    3585 [ +  - ][ +  - ]:        816 :                 l2n(s->hit ? 0 : s->session->timeout, p);
         [ +  - ][ +  - ]
    3586                 :            : 
    3587                 :            :                 /* Skip ticket length for now */
    3588                 :        816 :                 p += 2;
    3589                 :            :                 /* Output key name */
    3590                 :        816 :                 macstart = p;
    3591                 :        816 :                 memcpy(p, key_name, 16);
    3592                 :        816 :                 p += 16;
    3593                 :            :                 /* output IV */
    3594                 :        816 :                 memcpy(p, iv, EVP_CIPHER_CTX_iv_length(&ctx));
    3595                 :        816 :                 p += EVP_CIPHER_CTX_iv_length(&ctx);
    3596                 :            :                 /* Encrypt session data */
    3597                 :        816 :                 EVP_EncryptUpdate(&ctx, p, &len, senc, slen);
    3598                 :        816 :                 p += len;
    3599                 :        816 :                 EVP_EncryptFinal(&ctx, p, &len);
    3600                 :        816 :                 p += len;
    3601                 :        816 :                 EVP_CIPHER_CTX_cleanup(&ctx);
    3602                 :            : 
    3603                 :        816 :                 HMAC_Update(&hctx, macstart, p - macstart);
    3604                 :        816 :                 HMAC_Final(&hctx, p, &hlen);
    3605                 :        816 :                 HMAC_CTX_cleanup(&hctx);
    3606                 :            : 
    3607                 :        816 :                 p += hlen;
    3608                 :            :                 /* Now write out lengths: p points to end of data written */
    3609                 :            :                 /* Total length */
    3610                 :        816 :                 len = p - ssl_handshake_start(s);
    3611                 :        816 :                 ssl_set_handshake_header(s, SSL3_MT_NEWSESSION_TICKET, len);
    3612                 :            :                 /* Skip ticket lifetime hint */
    3613                 :        816 :                 p = ssl_handshake_start(s) + 4;
    3614                 :        816 :                 s2n(len - 6, p);
    3615                 :        816 :                 s->state=SSL3_ST_SW_SESSION_TICKET_B;
    3616                 :        816 :                 OPENSSL_free(senc);
    3617                 :            :                 }
    3618                 :            : 
    3619                 :            :         /* SSL3_ST_SW_SESSION_TICKET_B */
    3620                 :        816 :         return ssl_do_write(s);
    3621                 :            :         }
    3622                 :            : 
    3623                 :          0 : int ssl3_send_cert_status(SSL *s)
    3624                 :            :         {
    3625         [ #  # ]:          0 :         if (s->state == SSL3_ST_SW_CERT_STATUS_A)
    3626                 :            :                 {
    3627                 :            :                 unsigned char *p;
    3628                 :            :                 /* Grow buffer if need be: the length calculation is as
    3629                 :            :                  * follows 1 (message type) + 3 (message length) +
    3630                 :            :                  * 1 (ocsp response type) + 3 (ocsp response length)
    3631                 :            :                  * + (ocsp response)
    3632                 :            :                  */
    3633         [ #  # ]:          0 :                 if (!BUF_MEM_grow(s->init_buf, 8 + s->tlsext_ocsp_resplen))
    3634                 :            :                         return -1;
    3635                 :            : 
    3636                 :          0 :                 p=(unsigned char *)s->init_buf->data;
    3637                 :            : 
    3638                 :            :                 /* do the header */
    3639                 :          0 :                 *(p++)=SSL3_MT_CERTIFICATE_STATUS;
    3640                 :            :                 /* message length */
    3641                 :          0 :                 l2n3(s->tlsext_ocsp_resplen + 4, p);
    3642                 :            :                 /* status type */
    3643                 :          0 :                 *(p++)= s->tlsext_status_type;
    3644                 :            :                 /* length of OCSP response */
    3645                 :          0 :                 l2n3(s->tlsext_ocsp_resplen, p);
    3646                 :            :                 /* actual response */
    3647                 :          0 :                 memcpy(p, s->tlsext_ocsp_resp, s->tlsext_ocsp_resplen);
    3648                 :            :                 /* number of bytes to write */
    3649                 :          0 :                 s->init_num = 8 + s->tlsext_ocsp_resplen;
    3650                 :          0 :                 s->state=SSL3_ST_SW_CERT_STATUS_B;
    3651                 :          0 :                 s->init_off = 0;
    3652                 :            :                 }
    3653                 :            : 
    3654                 :            :         /* SSL3_ST_SW_CERT_STATUS_B */
    3655                 :          0 :         return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
    3656                 :            :         }
    3657                 :            : 
    3658                 :            : # ifndef OPENSSL_NO_NEXTPROTONEG
    3659                 :            : /* ssl3_get_next_proto reads a Next Protocol Negotiation handshake message. It
    3660                 :            :  * sets the next_proto member in s if found */
    3661                 :        231 : int ssl3_get_next_proto(SSL *s)
    3662                 :            :         {
    3663                 :            :         int ok;
    3664                 :            :         int proto_len, padding_len;
    3665                 :            :         long n;
    3666                 :            :         const unsigned char *p;
    3667                 :            : 
    3668                 :            :         /* Clients cannot send a NextProtocol message if we didn't see the
    3669                 :            :          * extension in their ClientHello */
    3670         [ -  + ]:        231 :         if (!s->s3->next_proto_neg_seen)
    3671                 :            :                 {
    3672                 :          0 :                 SSLerr(SSL_F_SSL3_GET_NEXT_PROTO,SSL_R_GOT_NEXT_PROTO_WITHOUT_EXTENSION);
    3673                 :          0 :                 return -1;
    3674                 :            :                 }
    3675                 :            : 
    3676                 :        231 :         n=s->method->ssl_get_message(s,
    3677                 :            :                 SSL3_ST_SR_NEXT_PROTO_A,
    3678                 :            :                 SSL3_ST_SR_NEXT_PROTO_B,
    3679                 :            :                 SSL3_MT_NEXT_PROTO,
    3680                 :            :                 514,  /* See the payload format below */
    3681                 :            :                 &ok);
    3682                 :            : 
    3683         [ +  + ]:        231 :         if (!ok)
    3684                 :        176 :                 return((int)n);
    3685                 :            : 
    3686                 :            :         /* s->state doesn't reflect whether ChangeCipherSpec has been received
    3687                 :            :          * in this handshake, but s->s3->change_cipher_spec does (will be reset
    3688                 :            :          * by ssl3_get_finished). */
    3689         [ -  + ]:         55 :         if (!s->s3->change_cipher_spec)
    3690                 :            :                 {
    3691                 :          0 :                 SSLerr(SSL_F_SSL3_GET_NEXT_PROTO,SSL_R_GOT_NEXT_PROTO_BEFORE_A_CCS);
    3692                 :          0 :                 return -1;
    3693                 :            :                 }
    3694                 :            : 
    3695         [ +  - ]:         55 :         if (n < 2)
    3696                 :            :                 return 0;  /* The body must be > 1 bytes long */
    3697                 :            : 
    3698                 :         55 :         p=(unsigned char *)s->init_msg;
    3699                 :            : 
    3700                 :            :         /* The payload looks like:
    3701                 :            :          *   uint8 proto_len;
    3702                 :            :          *   uint8 proto[proto_len];
    3703                 :            :          *   uint8 padding_len;
    3704                 :            :          *   uint8 padding[padding_len];
    3705                 :            :          */
    3706                 :         55 :         proto_len = p[0];
    3707         [ +  - ]:         55 :         if (proto_len + 2 > s->init_num)
    3708                 :            :                 return 0;
    3709                 :         55 :         padding_len = p[proto_len + 1];
    3710         [ +  - ]:         55 :         if (proto_len + padding_len + 2 != s->init_num)
    3711                 :            :                 return 0;
    3712                 :            : 
    3713                 :         55 :         s->next_proto_negotiated = OPENSSL_malloc(proto_len);
    3714         [ -  + ]:         55 :         if (!s->next_proto_negotiated)
    3715                 :            :                 {
    3716                 :          0 :                 SSLerr(SSL_F_SSL3_GET_NEXT_PROTO,ERR_R_MALLOC_FAILURE);
    3717                 :          0 :                 return 0;
    3718                 :            :                 }
    3719                 :         55 :         memcpy(s->next_proto_negotiated, p + 1, proto_len);
    3720                 :         55 :         s->next_proto_negotiated_len = proto_len;
    3721                 :            : 
    3722                 :         55 :         return 1;
    3723                 :            :         }
    3724                 :            : # endif
    3725                 :            : 
    3726                 :            : #endif

Generated by: LCOV version 1.9