authenticator.data = p;
authenticator.data = (char *)p;
static int ssl3_get_client_key_exchange(SSL *s)	{	int i,al,ok;	long n;	unsigned long l;	unsigned char *p;#ifndef OPENSSL_NO_RSA	RSA *rsa=NULL;	EVP_PKEY *pkey=NULL;#endif#ifndef OPENSSL_NO_DH	BIGNUM *pub=NULL;	DH *dh_srvr;#endif#ifndef OPENSSL_NO_KRB5        KSSL_ERR kssl_err;#endif /* OPENSSL_NO_KRB5 */	n=ssl3_get_message(s,		SSL3_ST_SR_KEY_EXCH_A,		SSL3_ST_SR_KEY_EXCH_B,		SSL3_MT_CLIENT_KEY_EXCHANGE,		2048, /* ??? */		&ok);	if (!ok) return((int)n);	p=(unsigned char *)s->init_msg;	l=s->s3->tmp.new_cipher->algorithms;#ifndef OPENSSL_NO_RSA	if (l & SSL_kRSA)		{		/* FIX THIS UP EAY EAY EAY EAY */		if (s->s3->tmp.use_rsa_tmp)			{			if ((s->cert != NULL) && (s->cert->rsa_tmp != NULL))				rsa=s->cert->rsa_tmp;			/* Don't do a callback because rsa_tmp should			 * be sent already */			if (rsa == NULL)				{				al=SSL_AD_HANDSHAKE_FAILURE;				SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_TMP_RSA_PKEY);				goto f_err;				}			}		else			{			pkey=s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey;			if (	(pkey == NULL) ||				(pkey->type != EVP_PKEY_RSA) ||				(pkey->pkey.rsa == NULL))				{				al=SSL_AD_HANDSHAKE_FAILURE;				SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_RSA_CERTIFICATE);				goto f_err;				}			rsa=pkey->pkey.rsa;			}		/* TLS */		if (s->version > SSL3_VERSION)			{			n2s(p,i);			if (n != i+2)				{				if (!(s->options & SSL_OP_TLS_D5_BUG))					{					SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG);					goto err;					}				else					p-=2;				}			else				n=i;			}		i=RSA_private_decrypt((int)n,p,p,rsa,RSA_PKCS1_PADDING);		al = -1;				if (i != SSL_MAX_MASTER_KEY_LENGTH)			{			al=SSL_AD_DECODE_ERROR;			SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_BAD_RSA_DECRYPT);			}		if ((al == -1) && !((p[0] == (s->client_version>>8)) && (p[1] == (s->client_version & 0xff))))			{			/* The premaster secret must contain the same version number as the			 * ClientHello to detect version rollback attacks (strangely, the			 * protocol does not offer such protection for DH ciphersuites).			 * However, buggy clients exist that send the negotiated protocol			 * version instead if the server does not support the requested			 * protocol version.			 * If SSL_OP_TLS_ROLLBACK_BUG is set, tolerate such clients. */			if (!((s->options & SSL_OP_TLS_ROLLBACK_BUG) &&				(p[0] == (s->version>>8)) && (p[1] == (s->version & 0xff))))				{				al=SSL_AD_DECODE_ERROR;				SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_BAD_PROTOCOL_VERSION_NUMBER);				goto f_err;				}			}		if (al != -1)			{#if 0			goto f_err;#else			/* Some decryption failure -- use random value instead as countermeasure			 * against Bleichenbacher's attack on PKCS #1 v1.5 RSA padding			 * (see RFC 2246, section 7.4.7.1).			 * But note that due to length and protocol version checking, the			 * attack is impractical anyway (see section 5 in D. Bleichenbacher:			 * "Chosen Ciphertext Attacks Against Protocols Based on the RSA			 * Encryption Standard PKCS #1", CRYPTO '98, LNCS 1462, pp. 1-12).			 */			ERR_clear_error();			i = SSL_MAX_MASTER_KEY_LENGTH;			p[0] = s->client_version >> 8;			p[1] = s->client_version & 0xff;			RAND_pseudo_bytes(p+2, i-2); /* should be RAND_bytes, but we cannot work around a failure */#endif			}			s->session->master_key_length=			s->method->ssl3_enc->generate_master_secret(s,				s->session->master_key,				p,i);		memset(p,0,i);		}	else#endif#ifndef OPENSSL_NO_DH		if (l & (SSL_kEDH|SSL_kDHr|SSL_kDHd))		{		n2s(p,i);		if (n != i+2)			{			if (!(s->options & SSL_OP_SSLEAY_080_CLIENT_DH_BUG))				{				SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG);				goto err;				}			else				{				p-=2;				i=(int)n;				}			}		if (n == 0L) /* the parameters are in the cert */			{			al=SSL_AD_HANDSHAKE_FAILURE;			SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_UNABLE_TO_DECODE_DH_CERTS);			goto f_err;			}		else			{			if (s->s3->tmp.dh == NULL)				{				al=SSL_AD_HANDSHAKE_FAILURE;				SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_TMP_DH_KEY);				goto f_err;				}			else				dh_srvr=s->s3->tmp.dh;			}		pub=BN_bin2bn(p,i,NULL);		if (pub == NULL)			{			SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_BN_LIB);			goto err;			}		i=DH_compute_key(p,pub,dh_srvr);		if (i <= 0)			{			SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,ERR_R_DH_LIB);			goto err;			}		DH_free(s->s3->tmp.dh);		s->s3->tmp.dh=NULL;		BN_clear_free(pub);		pub=NULL;		s->session->master_key_length=			s->method->ssl3_enc->generate_master_secret(s,				s->session->master_key,p,i);		memset(p,0,i);		}	else#endif#ifndef OPENSSL_NO_KRB5        if (l & SSL_kKRB5)                {                krb5_error_code		krb5rc;		krb5_data		enc_ticket;		krb5_data		authenticator;		krb5_data		enc_pms;                KSSL_CTX		*kssl_ctx = s->kssl_ctx;		EVP_CIPHER_CTX		ciph_ctx;		EVP_CIPHER		*enc = NULL;		unsigned char		iv[EVP_MAX_IV_LENGTH];		unsigned char		pms[SSL_MAX_MASTER_KEY_LENGTH						+ EVP_MAX_IV_LENGTH + 1];		int 			padl, outl = sizeof(pms);		krb5_timestamp		authtime = 0;		krb5_ticket_times	ttimes;                if (!kssl_ctx)  kssl_ctx = kssl_ctx_new();		n2s(p,i);		enc_ticket.length = i;		enc_ticket.data = p;		p+=enc_ticket.length;		n2s(p,i);		authenticator.length = i;		authenticator.data = p;		p+=authenticator.length;		n2s(p,i);		enc_pms.length = i;		enc_pms.data = p;		p+=enc_pms.length;		if ((unsigned long)n != enc_ticket.length + authenticator.length +						enc_pms.length + 6)			{			SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,				SSL_R_DATA_LENGTH_TOO_LONG);			goto err;			}                if ((krb5rc = kssl_sget_tkt(kssl_ctx, &enc_ticket, &ttimes,					&kssl_err)) != 0)                        {#ifdef KSSL_DEBUG                        printf("kssl_sget_tkt rtn %d [%d]\n",                                krb5rc, kssl_err.reason);                        if (kssl_err.text)                                printf("kssl_err text= %s\n", kssl_err.text);#endif	/* KSSL_DEBUG */                        SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,                                kssl_err.reason);                        goto err;                        }		/*  Note: no authenticator is not considered an error,		**  but will return authtime == 0.		*/		if ((krb5rc = kssl_check_authent(kssl_ctx, &authenticator,					&authtime, &kssl_err)) != 0)			{#ifdef KSSL_DEBUG                        printf("kssl_check_authent rtn %d [%d]\n",                                krb5rc, kssl_err.reason);                        if (kssl_err.text)                                printf("kssl_err text= %s\n", kssl_err.text);#endif	/* KSSL_DEBUG */                        SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,                                kssl_err.reason);                        goto err;			}		if ((krb5rc = kssl_validate_times(authtime, &ttimes)) != 0)			{			SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE, krb5rc);                        goto err;			}#ifdef KSSL_DEBUG                kssl_ctx_show(kssl_ctx);#endif	/* KSSL_DEBUG */		enc = kssl_map_enc(kssl_ctx->enctype);                if (enc == NULL)                    goto err;		memset(iv, 0, EVP_MAX_IV_LENGTH);	/* per RFC 1510 */		if (!EVP_DecryptInit_ex(&ciph_ctx,enc,NULL,kssl_ctx->key,iv))			{			SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,				SSL_R_DECRYPTION_FAILED);			goto err;			}		if (!EVP_DecryptUpdate(&ciph_ctx, pms,&outl,					enc_pms.data, enc_pms.length))			{			SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,				SSL_R_DECRYPTION_FAILED);			goto err;			}		if (outl > SSL_MAX_MASTER_KEY_LENGTH)			{			SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,				SSL_R_DATA_LENGTH_TOO_LONG);			goto err;			}		if (!EVP_DecryptFinal_ex(&ciph_ctx,&(pms[outl]),&padl))			{			SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,				SSL_R_DECRYPTION_FAILED);			goto err;			}		outl += padl;		if (outl > SSL_MAX_MASTER_KEY_LENGTH)			{			SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,				SSL_R_DATA_LENGTH_TOO_LONG);			goto err;			}		EVP_CIPHER_CTX_cleanup(&ciph_ctx);                s->session->master_key_length=                        s->method->ssl3_enc->generate_master_secret(s,                                s->session->master_key, pms, outl);                if (kssl_ctx->client_princ)                        {                        int len = strlen(kssl_ctx->client_princ);                        if ( len < SSL_MAX_KRB5_PRINCIPAL_LENGTH )                                 {                                s->session->krb5_client_princ_len = len;                                memcpy(s->session->krb5_client_princ,kssl_ctx->client_princ,len);                                }                        }                /*  Was doing kssl_ctx_free() here,		**  but it caused problems for apache.                **  kssl_ctx = kssl_ctx_free(kssl_ctx);                **  if (s->kssl_ctx)  s->kssl_ctx = NULL;                */                }	else#endif	/* OPENSSL_NO_KRB5 */		{		al=SSL_AD_HANDSHAKE_FAILURE;		SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,				SSL_R_UNKNOWN_CIPHER_TYPE);		goto f_err;		}	return(1);f_err:	ssl3_send_alert(s,SSL3_AL_FATAL,al);#if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_RSA)err:#endif	return(-1);	}