自学教程：C++ ssl3_cleanup_key_block函数代码示例

void ssl3_free(SSL *s) {  if (s == NULL || s->s3 == NULL) {    return;  }  ssl3_cleanup_key_block(s);  ssl_read_buffer_clear(s);  ssl_write_buffer_clear(s);  DH_free(s->s3->tmp.dh);  EC_KEY_free(s->s3->tmp.ecdh);  sk_X509_NAME_pop_free(s->s3->tmp.ca_names, X509_NAME_free);  OPENSSL_free(s->s3->tmp.certificate_types);  OPENSSL_free(s->s3->tmp.peer_ellipticcurvelist);  OPENSSL_free(s->s3->tmp.peer_psk_identity_hint);  DH_free(s->s3->tmp.peer_dh_tmp);  EC_KEY_free(s->s3->tmp.peer_ecdh_tmp);  ssl3_free_handshake_buffer(s);  ssl3_free_handshake_hash(s);  OPENSSL_free(s->s3->alpn_selected);  OPENSSL_cleanse(s->s3, sizeof *s->s3);  OPENSSL_free(s->s3);  s->s3 = NULL;}

void ssl3_free(SSL *ssl) {  if (ssl == NULL || ssl->s3 == NULL) {    return;  }  ssl3_cleanup_key_block(ssl);  ssl_read_buffer_clear(ssl);  ssl_write_buffer_clear(ssl);  SSL_ECDH_CTX_cleanup(&ssl->s3->tmp.ecdh_ctx);  OPENSSL_free(ssl->s3->tmp.peer_key);  sk_X509_NAME_pop_free(ssl->s3->tmp.ca_names, X509_NAME_free);  OPENSSL_free(ssl->s3->tmp.certificate_types);  OPENSSL_free(ssl->s3->tmp.peer_ellipticcurvelist);  OPENSSL_free(ssl->s3->tmp.peer_psk_identity_hint);  ssl3_free_handshake_buffer(ssl);  ssl3_free_handshake_hash(ssl);  OPENSSL_free(ssl->s3->next_proto_negotiated);  OPENSSL_free(ssl->s3->alpn_selected);  SSL_AEAD_CTX_free(ssl->s3->aead_read_ctx);  SSL_AEAD_CTX_free(ssl->s3->aead_write_ctx);  OPENSSL_cleanse(ssl->s3, sizeof *ssl->s3);  OPENSSL_free(ssl->s3);  ssl->s3 = NULL;}

int ssl3_setup_key_block(SSL *s)	{	unsigned char *p;	const EVP_CIPHER *c;	const EVP_MD *hash;	int num;	int ret = 0;	SSL_COMP *comp;	if (s->s3->tmp.key_block_length != 0)		return(1);	if (!ssl_cipher_get_evp(s->session,&c,&hash,&comp))		{		SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK,SSL_R_CIPHER_OR_HASH_UNAVAILABLE);		return(0);		}	s->s3->tmp.new_sym_enc=c;	s->s3->tmp.new_hash=hash;	s->s3->tmp.new_compression=comp;	num=EVP_CIPHER_key_length(c)+EVP_MD_size(hash)+EVP_CIPHER_iv_length(c);	num*=2;	ssl3_cleanup_key_block(s);	if ((p=OPENSSL_malloc(num)) == NULL)		goto err;	s->s3->tmp.key_block_length=num;	s->s3->tmp.key_block=p;	ret = ssl3_generate_key_block(s,p,num);	if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS))		{		/* enable vulnerability countermeasure for CBC ciphers with		 * known-IV problem (http://www.openssl.org/~bodo/tls-cbc.txt)		 */		s->s3->need_empty_fragments = 1;		if (s->session->cipher != NULL)			{			if ((s->session->cipher->algorithms & SSL_ENC_MASK) == SSL_eNULL)				s->s3->need_empty_fragments = 0;			#ifndef OPENSSL_NO_RC4			if ((s->session->cipher->algorithms & SSL_ENC_MASK) == SSL_RC4)				s->s3->need_empty_fragments = 0;#endif			}		}	return ret;		err:	SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK,ERR_R_MALLOC_FAILURE);	return(0);	}

void ssl3_free(SSL *ssl) {  if (ssl == NULL || ssl->s3 == NULL) {    return;  }  ssl3_cleanup_key_block(ssl);  ssl_read_buffer_clear(ssl);  ssl_write_buffer_clear(ssl);  SSL_ECDH_CTX_cleanup(&ssl->s3->tmp.ecdh_ctx);  OPENSSL_free(ssl->s3->tmp.peer_key);  OPENSSL_free(ssl->s3->tmp.server_params);  sk_X509_NAME_pop_free(ssl->s3->tmp.ca_names, X509_NAME_free);  OPENSSL_free(ssl->s3->tmp.certificate_types);  OPENSSL_free(ssl->s3->tmp.peer_supported_group_list);  OPENSSL_free(ssl->s3->tmp.peer_psk_identity_hint);  SSL_SESSION_free(ssl->s3->new_session);  SSL_SESSION_free(ssl->s3->established_session);  ssl3_free_handshake_buffer(ssl);  ssl3_free_handshake_hash(ssl);  ssl_handshake_free(ssl->s3->hs);  OPENSSL_free(ssl->s3->next_proto_negotiated);  OPENSSL_free(ssl->s3->alpn_selected);  SSL_AEAD_CTX_free(ssl->s3->aead_read_ctx);  SSL_AEAD_CTX_free(ssl->s3->aead_write_ctx);  OPENSSL_free(ssl->s3->pending_message);  OPENSSL_cleanse(ssl->s3, sizeof *ssl->s3);  OPENSSL_free(ssl->s3);  ssl->s3 = NULL;}

int tls1_setup_key_block(SSL *ssl) {  if (ssl->s3->tmp.key_block_length != 0) {    return 1;  }  SSL_SESSION *session = ssl->session;  if (ssl->s3->new_session != NULL) {    session = ssl->s3->new_session;  }  const EVP_AEAD *aead = NULL;  size_t mac_secret_len, fixed_iv_len;  if (session->cipher == NULL ||      !ssl_cipher_get_evp_aead(&aead, &mac_secret_len, &fixed_iv_len,                               session->cipher, ssl3_protocol_version(ssl))) {    OPENSSL_PUT_ERROR(SSL, SSL_R_CIPHER_OR_HASH_UNAVAILABLE);    return 0;  }  size_t key_len = EVP_AEAD_key_length(aead);  if (mac_secret_len > 0) {    /* For "stateful" AEADs (i.e. compatibility with pre-AEAD cipher suites) the     * key length reported by |EVP_AEAD_key_length| will include the MAC key     * bytes and initial implicit IV. */    if (key_len < mac_secret_len + fixed_iv_len) {      OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);      return 0;    }    key_len -= mac_secret_len + fixed_iv_len;  }  assert(mac_secret_len < 256);  assert(key_len < 256);  assert(fixed_iv_len < 256);  ssl->s3->tmp.new_mac_secret_len = (uint8_t)mac_secret_len;  ssl->s3->tmp.new_key_len = (uint8_t)key_len;  ssl->s3->tmp.new_fixed_iv_len = (uint8_t)fixed_iv_len;  size_t key_block_len = SSL_get_key_block_len(ssl);  ssl3_cleanup_key_block(ssl);  uint8_t *keyblock = OPENSSL_malloc(key_block_len);  if (keyblock == NULL) {    OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);    return 0;  }  if (!SSL_generate_key_block(ssl, keyblock, key_block_len)) {    OPENSSL_free(keyblock);    return 0;  }  assert(key_block_len < 256);  ssl->s3->tmp.key_block_length = (uint8_t)key_block_len;  ssl->s3->tmp.key_block = keyblock;  return 1;}

int ssl3_setup_key_block(SSL *s)	{	unsigned char *p;	const EVP_CIPHER *c;	const EVP_MD *hash;	int num;	SSL_COMP *comp;	if (s->s3->tmp.key_block_length != 0)		return(1);	if (!ssl_cipher_get_evp(s->session,&c,&hash,&comp))		{		SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK,SSL_R_CIPHER_OR_HASH_UNAVAILABLE);		return(0);		}	s->s3->tmp.new_sym_enc=c;	s->s3->tmp.new_hash=hash;	s->s3->tmp.new_compression=comp;	num=EVP_CIPHER_key_length(c)+EVP_MD_size(hash)+EVP_CIPHER_iv_length(c);	num*=2;	ssl3_cleanup_key_block(s);	if ((p=OPENSSL_malloc(num)) == NULL)		goto err;	s->s3->tmp.key_block_length=num;	s->s3->tmp.key_block=p;	ssl3_generate_key_block(s,p,num);	return(1);err:	SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK,ERR_R_MALLOC_FAILURE);	return(0);	}

void ssl3_free(SSL *ssl) {  if (ssl == NULL || ssl->s3 == NULL) {    return;  }  ssl3_cleanup_key_block(ssl);  ssl_read_buffer_clear(ssl);  ssl_write_buffer_clear(ssl);  SSL_SESSION_free(ssl->s3->new_session);  SSL_SESSION_free(ssl->s3->established_session);  ssl3_free_handshake_buffer(ssl);  ssl3_free_handshake_hash(ssl);  ssl_handshake_free(ssl->s3->hs);  OPENSSL_free(ssl->s3->next_proto_negotiated);  OPENSSL_free(ssl->s3->alpn_selected);  SSL_AEAD_CTX_free(ssl->s3->aead_read_ctx);  SSL_AEAD_CTX_free(ssl->s3->aead_write_ctx);  OPENSSL_free(ssl->s3->pending_message);  OPENSSL_cleanse(ssl->s3, sizeof *ssl->s3);  OPENSSL_free(ssl->s3);  ssl->s3 = NULL;}

//.........这里部分代码省略.........#ifndef OPENSSL_NO_SCTP			if (!s->hit)				{				/* Change to new shared key of SCTP-Auth,				 * will be ignored if no SCTP used.				 */				BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY, 0, NULL);				}#endif			s->state=SSL3_ST_SW_FINISHED_A;			s->init_num=0;			if (!s->method->ssl3_enc->change_cipher_state(s,				SSL3_CHANGE_CIPHER_SERVER_WRITE))				{				ret= -1;				goto end;				}			dtls1_reset_seq_numbers(s, SSL3_CC_WRITE);			break;		case SSL3_ST_SW_FINISHED_A:		case SSL3_ST_SW_FINISHED_B:			ret=ssl3_send_finished(s,				SSL3_ST_SW_FINISHED_A,SSL3_ST_SW_FINISHED_B,				s->method->ssl3_enc->server_finished_label,				s->method->ssl3_enc->server_finished_label_len);			if (ret <= 0) goto end;			s->state=SSL3_ST_SW_FLUSH;			if (s->hit)				{				s->s3->tmp.next_state=SSL3_ST_SR_FINISHED_A;#ifndef OPENSSL_NO_SCTP				/* Change to new shared key of SCTP-Auth,				 * will be ignored if no SCTP used.				 */				BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY, 0, NULL);#endif				}			else				{				s->s3->tmp.next_state=SSL_ST_OK;#ifndef OPENSSL_NO_SCTP				if (BIO_dgram_is_sctp(SSL_get_wbio(s)))					{					s->d1->next_state = s->s3->tmp.next_state;					s->s3->tmp.next_state=DTLS1_SCTP_ST_SW_WRITE_SOCK;					}#endif				}			s->init_num=0;			break;		case SSL_ST_OK:			/* clean a few things up */			ssl3_cleanup_key_block(s);#if 0			BUF_MEM_free(s->init_buf);			s->init_buf=NULL;#endif			/* remove buffering on output */			ssl_free_wbio_buffer(s);			s->init_num=0;			if (s->renegotiate == 2) /* skipped if we just sent a HelloRequest */				{				s->renegotiate=0;				s->new_session=0;								ssl_update_cache(s,SSL_SESS_CACHE_SERVER);								s->ctx->stats.sess_accept_good++;				/* s->server=1; */				s->handshake_func=dtls1_accept;				if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);				}						ret = 1;			/* done handshaking, next message is client hello */			s->d1->handshake_read_seq = 0;			/* next message is server hello */			s->d1->handshake_write_seq = 0;			s->d1->next_handshake_write_seq = 0;			goto end;			/* break; */		default:			SSLerr(SSL_F_DTLS1_ACCEPT,SSL_R_UNKNOWN_STATE);			ret= -1;			goto end;			/* break; */			}

//.........这里部分代码省略.........			s->state=SSL3_ST_CR_FINISHED_A;			s->init_num=0;		break;		case SSL3_ST_CR_CERT_STATUS_A:		case SSL3_ST_CR_CERT_STATUS_B:			ret=ssl3_get_cert_status(s);			if (ret <= 0) goto end;			s->state=SSL3_ST_CR_KEY_EXCH_A;			s->init_num=0;		break;#endif		case SSL3_ST_CR_FINISHED_A:		case SSL3_ST_CR_FINISHED_B:			s->d1->change_cipher_spec_ok = 1;			ret=ssl3_get_finished(s,SSL3_ST_CR_FINISHED_A,				SSL3_ST_CR_FINISHED_B);			if (ret <= 0) goto end;			dtls1_stop_timer(s);			if (s->hit)				s->state=SSL3_ST_CW_CHANGE_A;			else				s->state=SSL_ST_OK;#ifndef OPENSSL_NO_SCTP			if (BIO_dgram_is_sctp(SSL_get_wbio(s)) &&				state == SSL_ST_RENEGOTIATE)				{				s->d1->next_state=s->state;				s->state=DTLS1_SCTP_ST_CW_WRITE_SOCK;				}#endif			s->init_num=0;			break;		case SSL3_ST_CW_FLUSH:			s->rwstate=SSL_WRITING;			if (BIO_flush(s->wbio) <= 0)				{				/* If the write error was fatal, stop trying */				if (!BIO_should_retry(s->wbio))					{					s->rwstate=SSL_NOTHING;					s->state=s->s3->tmp.next_state;					}								ret= -1;				goto end;				}			s->rwstate=SSL_NOTHING;			s->state=s->s3->tmp.next_state;			break;		case SSL_ST_OK:			/* clean a few things up */			ssl3_cleanup_key_block(s);#if 0			if (s->init_buf != NULL)				{				BUF_MEM_free(s->init_buf);				s->init_buf=NULL;				}#endif			/* If we are not 'joining' the last two packets,			 * remove the buffering now */			if (!(s->s3->flags & SSL3_FLAGS_POP_BUFFER))				ssl_free_wbio_buffer(s);			/* else do it later in ssl3_write */			s->init_num=0;			s->renegotiate=0;			s->new_session=0;			ssl_update_cache(s,SSL_SESS_CACHE_CLIENT);			if (s->hit) s->ctx->stats.sess_hit++;			ret=1;			/* s->server=0; */			s->handshake_func=dtls1_connect;			s->ctx->stats.sess_connect_good++;			if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);			/* done with handshaking */			s->d1->handshake_read_seq  = 0;			s->d1->next_handshake_write_seq = 0;			goto end;			/* break; */					default:			SSLerr(SSL_F_DTLS1_CONNECT,SSL_R_UNKNOWN_STATE);			ret= -1;			goto end;			/* break; */			}

//.........这里部分代码省略.........			if (ret <= 0) goto end;			s->state=SSL3_ST_SW_CHANGE_A;			s->init_num=0;			break;		case SSL3_ST_SW_CERT_STATUS_A:		case SSL3_ST_SW_CERT_STATUS_B:			ret=ssl3_send_cert_status(s);			if (ret <= 0) goto end;			s->state=SSL3_ST_SW_KEY_EXCH_A;			s->init_num=0;			break;#endif		case SSL3_ST_SW_CHANGE_A:		case SSL3_ST_SW_CHANGE_B:			s->session->cipher=s->s3->tmp.new_cipher;			if (!s->method->ssl3_enc->setup_key_block(s))				{ ret= -1; goto end; }			ret=dtls1_send_change_cipher_spec(s,				SSL3_ST_SW_CHANGE_A,SSL3_ST_SW_CHANGE_B);			if (ret <= 0) goto end;			s->state=SSL3_ST_SW_FINISHED_A;			s->init_num=0;			if (!s->method->ssl3_enc->change_cipher_state(s,				SSL3_CHANGE_CIPHER_SERVER_WRITE))				{				ret= -1;				goto end;				}			dtls1_reset_seq_numbers(s, SSL3_CC_WRITE);			break;		case SSL3_ST_SW_FINISHED_A:		case SSL3_ST_SW_FINISHED_B:			ret=dtls1_send_finished(s,				SSL3_ST_SW_FINISHED_A,SSL3_ST_SW_FINISHED_B,				s->method->ssl3_enc->server_finished_label,				s->method->ssl3_enc->server_finished_label_len);			if (ret <= 0) goto end;			s->state=SSL3_ST_SW_FLUSH;			if (s->hit)				s->s3->tmp.next_state=SSL3_ST_SR_FINISHED_A;			else				s->s3->tmp.next_state=SSL_ST_OK;			s->init_num=0;			break;		case SSL_ST_OK:			/* clean a few things up */			ssl3_cleanup_key_block(s);#if 0			BUF_MEM_free(s->init_buf);			s->init_buf=NULL;#endif			/* remove buffering on output */			ssl_free_wbio_buffer(s);			s->init_num=0;			if (s->new_session == 2) /* skipped if we just sent a HelloRequest */				{				/* actually not necessarily a 'new' session unless				 * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION is set */								s->new_session=0;								ssl_update_cache(s,SSL_SESS_CACHE_SERVER);								s->ctx->stats.sess_accept_good++;				/* s->server=1; */				s->handshake_func=dtls1_accept;				if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);				}						ret = 1;			/* done handshaking, next message is client hello */			s->d1->handshake_read_seq = 0;			/* next message is server hello */			s->d1->handshake_write_seq = 0;			s->d1->next_handshake_write_seq = 0;			goto end;			/* break; */		default:			SSLerr(SSL_F_DTLS1_ACCEPT,SSL_R_UNKNOWN_STATE);			ret= -1;			goto end;			/* break; */			}

int tls1_setup_key_block(SSL *s)	{	unsigned char *p1,*p2=NULL;	const EVP_CIPHER *c;	const EVP_MD *hash;	int num;	SSL_COMP *comp;	int mac_type= NID_undef,mac_secret_size=0;	int ret=0;#ifdef KSSL_DEBUG	TINYCLR_SSL_PRINTF ("tls1_setup_key_block()/n");#endif	/* KSSL_DEBUG */	if (s->s3->tmp.key_block_length != 0)		return(1);	if (!ssl_cipher_get_evp(s->session,&c,&hash,&mac_type,&mac_secret_size,&comp))		{		SSLerr(SSL_F_TLS1_SETUP_KEY_BLOCK,SSL_R_CIPHER_OR_HASH_UNAVAILABLE);		return(0);		}	s->s3->tmp.new_sym_enc=c;	s->s3->tmp.new_hash=hash;	s->s3->tmp.new_mac_pkey_type = mac_type;	s->s3->tmp.new_mac_secret_size = mac_secret_size;	num=EVP_CIPHER_key_length(c)+mac_secret_size+EVP_CIPHER_iv_length(c);	num*=2;	ssl3_cleanup_key_block(s);	if ((p1=(unsigned char *)OPENSSL_malloc(num)) == NULL)		{		SSLerr(SSL_F_TLS1_SETUP_KEY_BLOCK,ERR_R_MALLOC_FAILURE);		goto err;		}	s->s3->tmp.key_block_length=num;	s->s3->tmp.key_block=p1;	if ((p2=(unsigned char *)OPENSSL_malloc(num)) == NULL)		{		SSLerr(SSL_F_TLS1_SETUP_KEY_BLOCK,ERR_R_MALLOC_FAILURE);		goto err;		}#ifdef TLS_DEBUGTINYCLR_SSL_PRINTF("client random/n");{ int z; for (z=0; z<SSL3_RANDOM_SIZE; z++) TINYCLR_SSL_PRINTF("%02X%c",s->s3->client_random[z],((z+1)%16)?' ':'/n'); }TINYCLR_SSL_PRINTF("server random/n");{ int z; for (z=0; z<SSL3_RANDOM_SIZE; z++) TINYCLR_SSL_PRINTF("%02X%c",s->s3->server_random[z],((z+1)%16)?' ':'/n'); }TINYCLR_SSL_PRINTF("pre-master/n");{ int z; for (z=0; z<s->session->master_key_length; z++) TINYCLR_SSL_PRINTF("%02X%c",s->session->master_key[z],((z+1)%16)?' ':'/n'); }#endif	if (!tls1_generate_key_block(s,p1,p2,num))		goto err;#ifdef TLS_DEBUGTINYCLR_SSL_PRINTF("/nkey block/n");{ int z; for (z=0; z<num; z++) TINYCLR_SSL_PRINTF("%02X%c",p1[z],((z+1)%16)?' ':'/n'); }#endif	if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS))		{		/* enable vulnerability countermeasure for CBC ciphers with		 * known-IV problem (http://www.openssl.org/~bodo/tls-cbc.txt)		 */		s->s3->need_empty_fragments = 1;		if (s->session->cipher != NULL)			{			if (s->session->cipher->algorithm_enc == SSL_eNULL)				s->s3->need_empty_fragments = 0;			#ifndef OPENSSL_NO_RC4			if (s->session->cipher->algorithm_enc == SSL_RC4)				s->s3->need_empty_fragments = 0;#endif			}		}			ret = 1;err:	if (p2)		{		OPENSSL_cleanse(p2,num);		OPENSSL_free(p2);		}	return(ret);	}

//.........这里部分代码省略.........				{#ifndef OPENSSL_NO_TLSEXT				/* Allow NewSessionTicket if ticket expected */				if (s->tlsext_ticket_expected)					s->s3->tmp.next_state=SSL3_ST_CR_SESSION_TICKET_A;				else#endif								s->s3->tmp.next_state=SSL3_ST_CR_FINISHED_A;				}			s->init_num=0;			break;#ifndef OPENSSL_NO_TLSEXT		case SSL3_ST_CR_SESSION_TICKET_A:		case SSL3_ST_CR_SESSION_TICKET_B:			ret=ssl3_get_new_session_ticket(s);			if (ret <= 0) goto end;			s->state=SSL3_ST_CR_FINISHED_A;			s->init_num=0;		break;		case SSL3_ST_CR_CERT_STATUS_A:		case SSL3_ST_CR_CERT_STATUS_B:			ret=ssl3_get_cert_status(s);			if (ret <= 0) goto end;			s->state=SSL3_ST_CR_KEY_EXCH_A;			s->init_num=0;		break;#endif		case SSL3_ST_CR_FINISHED_A:		case SSL3_ST_CR_FINISHED_B:			s->d1->change_cipher_spec_ok = 1;			ret=ssl3_get_finished(s,SSL3_ST_CR_FINISHED_A,				SSL3_ST_CR_FINISHED_B);			if (ret <= 0) goto end;			dtls1_stop_timer(s);			if (s->hit)				s->state=SSL3_ST_CW_CHANGE_A;			else				s->state=SSL_ST_OK;			s->init_num=0;			break;		case SSL3_ST_CW_FLUSH:			s->rwstate=SSL_WRITING;			if (BIO_flush(s->wbio) <= 0)				{				ret= -1;				goto end;				}			s->rwstate=SSL_NOTHING;			s->state=s->s3->tmp.next_state;			break;		case SSL_ST_OK:			/* clean a few things up */			ssl3_cleanup_key_block(s);#if 0			if (s->init_buf != NULL)				{				BUF_MEM_free(s->init_buf);				s->init_buf=NULL;				}#endif			/* If we are not 'joining' the last two packets,			 * remove the buffering now */			if (!(s->s3->flags & SSL3_FLAGS_POP_BUFFER))				ssl_free_wbio_buffer(s);			/* else do it later in ssl3_write */			s->init_num=0;			s->new_session=0;			ssl_update_cache(s,SSL_SESS_CACHE_CLIENT);			if (s->hit) s->ctx->stats.sess_hit++;			ret=1;			/* s->server=0; */			s->handshake_func=dtls1_connect;			s->ctx->stats.sess_connect_good++;			if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);			/* done with handshaking */			s->d1->handshake_read_seq  = 0;			s->d1->next_handshake_write_seq = 0;			goto end;			/* break; */					default:			SSLerr(SSL_F_DTLS1_CONNECT,SSL_R_UNKNOWN_STATE);			ret= -1;			goto end;			/* break; */			}

//.........这里部分代码省略.........        ret = ssl3_send_new_session_ticket(s);        if (ret <= 0) {          goto end;        }        s->state = SSL3_ST_SW_CHANGE_A;        s->init_num = 0;        break;      case SSL3_ST_SW_CHANGE_A:      case SSL3_ST_SW_CHANGE_B:        s->session->cipher = s->s3->tmp.new_cipher;        if (!s->enc_method->setup_key_block(s)) {          ret = -1;          goto end;        }        ret = dtls1_send_change_cipher_spec(s, SSL3_ST_SW_CHANGE_A,                                            SSL3_ST_SW_CHANGE_B);        if (ret <= 0) {          goto end;        }        s->state = SSL3_ST_SW_FINISHED_A;        s->init_num = 0;        if (!s->enc_method->change_cipher_state(                s, SSL3_CHANGE_CIPHER_SERVER_WRITE)) {          ret = -1;          goto end;        }        break;      case SSL3_ST_SW_FINISHED_A:      case SSL3_ST_SW_FINISHED_B:        ret =            ssl3_send_finished(s, SSL3_ST_SW_FINISHED_A, SSL3_ST_SW_FINISHED_B,                               s->enc_method->server_finished_label,                               s->enc_method->server_finished_label_len);        if (ret <= 0) {          goto end;        }        s->state = SSL3_ST_SW_FLUSH;        if (s->hit) {          s->s3->tmp.next_state = SSL3_ST_SR_CHANGE;        } else {          s->s3->tmp.next_state = SSL_ST_OK;        }        s->init_num = 0;        break;      case SSL_ST_OK:        ssl3_cleanup_key_block(s);        /* remove buffering on output */        ssl_free_wbio_buffer(s);        s->init_num = 0;        s->s3->initial_handshake_complete = 1;        ssl_update_cache(s, SSL_SESS_CACHE_SERVER);        if (cb != NULL) {          cb(s, SSL_CB_HANDSHAKE_DONE, 1);        }        ret = 1;        /* done handshaking, next message is client hello */        s->d1->handshake_read_seq = 0;        /* next message is server hello */        s->d1->handshake_write_seq = 0;        s->d1->next_handshake_write_seq = 0;        goto end;      default:        OPENSSL_PUT_ERROR(SSL, SSL_R_UNKNOWN_STATE);        ret = -1;        goto end;    }    if (!s->s3->tmp.reuse_message && !skip) {      if (cb != NULL && s->state != state) {        new_state = s->state;        s->state = state;        cb(s, SSL_CB_ACCEPT_LOOP, 1);        s->state = new_state;      }    }    skip = 0;  }end:  s->in_handshake--;  BUF_MEM_free(buf);  if (cb != NULL) {    cb(s, SSL_CB_ACCEPT_EXIT, ret);  }  return ret;}

int tls1_setup_key_block(SSL *s) {  uint8_t *p;  const EVP_AEAD *aead = NULL;  int ret = 0;  size_t mac_secret_len, fixed_iv_len, variable_iv_len, key_len;  size_t key_block_len;  if (s->s3->tmp.key_block_length != 0) {    return 1;  }  if (s->session->cipher == NULL) {    goto cipher_unavailable_err;  }  if (!ssl_cipher_get_evp_aead(&aead, &mac_secret_len, &fixed_iv_len,                               s->session->cipher,                               ssl3_version_from_wire(s, s->version))) {    goto cipher_unavailable_err;  }  key_len = EVP_AEAD_key_length(aead);  variable_iv_len = EVP_AEAD_nonce_length(aead);  if (mac_secret_len > 0) {    /* For "stateful" AEADs (i.e. compatibility with pre-AEAD cipher suites) the     * key length reported by |EVP_AEAD_key_length| will include the MAC key     * bytes and initial implicit IV. */    if (key_len < mac_secret_len + fixed_iv_len) {      OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);      return 0;    }    key_len -= mac_secret_len + fixed_iv_len;  } else {    /* The nonce is split into a fixed portion and a variable portion. */    if (variable_iv_len < fixed_iv_len) {      OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);      return 0;    }    variable_iv_len -= fixed_iv_len;  }  assert(mac_secret_len < 256);  assert(fixed_iv_len < 256);  assert(variable_iv_len < 256);  s->s3->tmp.new_aead = aead;  s->s3->tmp.new_mac_secret_len = (uint8_t)mac_secret_len;  s->s3->tmp.new_fixed_iv_len = (uint8_t)fixed_iv_len;  s->s3->tmp.new_variable_iv_len = (uint8_t)variable_iv_len;  key_block_len = key_len + mac_secret_len + fixed_iv_len;  key_block_len *= 2;  ssl3_cleanup_key_block(s);  p = (uint8_t *)OPENSSL_malloc(key_block_len);  if (p == NULL) {    OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);    goto err;  }  s->s3->tmp.key_block_length = key_block_len;  s->s3->tmp.key_block = p;  if (!tls1_generate_key_block(s, p, key_block_len)) {    goto err;  }  ret = 1;err:  return ret;cipher_unavailable_err:  OPENSSL_PUT_ERROR(SSL, SSL_R_CIPHER_OR_HASH_UNAVAILABLE);  return 0;}

//.........这里部分代码省略.........      case SSL3_ST_CR_SESSION_TICKET_A:      case SSL3_ST_CR_SESSION_TICKET_B:        ret = ssl3_get_new_session_ticket(s);        if (ret <= 0) {          goto end;        }        s->state = SSL3_ST_CR_FINISHED_A;        s->init_num = 0;        break;      case SSL3_ST_CR_CERT_STATUS_A:      case SSL3_ST_CR_CERT_STATUS_B:        ret = ssl3_get_cert_status(s);        if (ret <= 0) {          goto end;        }        s->state = SSL3_ST_VERIFY_SERVER_CERT;        s->init_num = 0;        break;      case SSL3_ST_CR_FINISHED_A:      case SSL3_ST_CR_FINISHED_B:        s->d1->change_cipher_spec_ok = 1;        ret =            ssl3_get_finished(s, SSL3_ST_CR_FINISHED_A, SSL3_ST_CR_FINISHED_B);        if (ret <= 0) {          goto end;        }        dtls1_stop_timer(s);        if (s->hit) {          s->state = SSL3_ST_CW_CHANGE_A;        } else {          s->state = SSL_ST_OK;        }        s->init_num = 0;        break;      case SSL3_ST_CW_FLUSH:        s->rwstate = SSL_WRITING;        if (BIO_flush(s->wbio) <= 0) {          ret = -1;          goto end;        }        s->rwstate = SSL_NOTHING;        s->state = s->s3->tmp.next_state;        break;      case SSL_ST_OK:        /* clean a few things up */        ssl3_cleanup_key_block(s);        /* Remove write buffering now. */        ssl_free_wbio_buffer(s);        s->init_num = 0;        s->s3->initial_handshake_complete = 1;        ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);        ret = 1;        if (cb != NULL) {          cb(s, SSL_CB_HANDSHAKE_DONE, 1);        }        /* done with handshaking */        s->d1->handshake_read_seq = 0;        s->d1->next_handshake_write_seq = 0;        goto end;      default:        OPENSSL_PUT_ERROR(SSL, SSL_R_UNKNOWN_STATE);        ret = -1;        goto end;    }    /* did we do anything? */    if (!s->s3->tmp.reuse_message && !skip) {      if ((cb != NULL) && (s->state != state)) {        new_state = s->state;        s->state = state;        cb(s, SSL_CB_CONNECT_LOOP, 1);        s->state = new_state;      }    }    skip = 0;  }end:  s->in_handshake--;  BUF_MEM_free(buf);  if (cb != NULL) {    cb(s, SSL_CB_CONNECT_EXIT, ret);  }  return ret;}

int tls1_setup_key_block(SSL *s) {  uint8_t *p;  const EVP_AEAD *aead = NULL;  int ret = 0;  size_t mac_secret_len, fixed_iv_len, variable_iv_len, key_len;  size_t key_block_len;  if (s->s3->tmp.key_block_length != 0) {    return 1;  }  if (s->session->cipher == NULL) {    goto cipher_unavailable_err;  }  if (!ssl_cipher_get_evp_aead(&aead, &mac_secret_len, &fixed_iv_len,                               s->session->cipher,                               ssl3_version_from_wire(s, s->version))) {    goto cipher_unavailable_err;  }  key_len = EVP_AEAD_key_length(aead);  variable_iv_len = EVP_AEAD_nonce_length(aead);  if (mac_secret_len > 0) {    /* For "stateful" AEADs (i.e. compatibility with pre-AEAD cipher suites) the     * key length reported by |EVP_AEAD_key_length| will include the MAC key     * bytes and initial implicit IV. */    if (key_len < mac_secret_len + fixed_iv_len) {      OPENSSL_PUT_ERROR(SSL, tls1_setup_key_block, ERR_R_INTERNAL_ERROR);      return 0;    }    key_len -= mac_secret_len + fixed_iv_len;  } else {    /* The nonce is split into a fixed portion and a variable portion. */    if (variable_iv_len < fixed_iv_len) {      OPENSSL_PUT_ERROR(SSL, tls1_setup_key_block, ERR_R_INTERNAL_ERROR);      return 0;    }    variable_iv_len -= fixed_iv_len;  }  assert(mac_secret_len < 256);  assert(fixed_iv_len < 256);  assert(variable_iv_len < 256);  s->s3->tmp.new_aead = aead;  s->s3->tmp.new_mac_secret_len = (uint8_t)mac_secret_len;  s->s3->tmp.new_fixed_iv_len = (uint8_t)fixed_iv_len;  s->s3->tmp.new_variable_iv_len = (uint8_t)variable_iv_len;  key_block_len = key_len + mac_secret_len + fixed_iv_len;  key_block_len *= 2;  ssl3_cleanup_key_block(s);  p = (uint8_t *)OPENSSL_malloc(key_block_len);  if (p == NULL) {    OPENSSL_PUT_ERROR(SSL, tls1_setup_key_block, ERR_R_MALLOC_FAILURE);    goto err;  }  s->s3->tmp.key_block_length = key_block_len;  s->s3->tmp.key_block = p;  if (!tls1_generate_key_block(s, p, key_block_len)) {    goto err;  }  if (!SSL_USE_EXPLICIT_IV(s) &&      (s->mode & SSL_MODE_CBC_RECORD_SPLITTING) != 0) {    /* enable vulnerability countermeasure for CBC ciphers with known-IV     * problem (http://www.openssl.org/~bodo/tls-cbc.txt). */    s->s3->need_record_splitting = 1;    if (s->session->cipher != NULL &&        s->session->cipher->algorithm_enc == SSL_RC4) {      s->s3->need_record_splitting = 0;    }  }  ret = 1;err:  return ret;cipher_unavailable_err:  OPENSSL_PUT_ERROR(SSL, tls1_setup_key_block,                    SSL_R_CIPHER_OR_HASH_UNAVAILABLE);  return 0;}

int tls1_setup_key_block(SSL *s)	{	unsigned char *p1,*p2;	const EVP_CIPHER *c;	const EVP_MD *hash;	int num;	SSL_COMP *comp;	if (s->s3->tmp.key_block_length != 0)		return(1);	if (!ssl_cipher_get_evp(s->session,&c,&hash,&comp))		{		SSLerr(SSL_F_TLS1_SETUP_KEY_BLOCK,SSL_R_CIPHER_OR_HASH_UNAVAILABLE);		return(0);		}	s->s3->tmp.new_sym_enc=c;	s->s3->tmp.new_hash=hash;	num=EVP_CIPHER_key_length(c)+EVP_MD_size(hash)+EVP_CIPHER_iv_length(c);	num*=2;	ssl3_cleanup_key_block(s);	if ((p1=(unsigned char *)OPENSSL_malloc(num)) == NULL)		goto err;	if ((p2=(unsigned char *)OPENSSL_malloc(num)) == NULL)		goto err;	s->s3->tmp.key_block_length=num;	s->s3->tmp.key_block=p1;#ifdef TLS_DEBUGprintf("client random/n");{ int z; for (z=0; z<SSL3_RANDOM_SIZE; z++) printf("%02X%c",s->s3->client_random[z],((z+1)%16)?' ':'/n'); }printf("server random/n");{ int z; for (z=0; z<SSL3_RANDOM_SIZE; z++) printf("%02X%c",s->s3->server_random[z],((z+1)%16)?' ':'/n'); }printf("pre-master/n");{ int z; for (z=0; z<s->session->master_key_length; z++) printf("%02X%c",s->session->master_key[z],((z+1)%16)?' ':'/n'); }#endif	tls1_generate_key_block(s,p1,p2,num);	memset(p2,0,num);	OPENSSL_free(p2);#ifdef TLS_DEBUGprintf("/nkey block/n");{ int z; for (z=0; z<num; z++) printf("%02X%c",p1[z],((z+1)%16)?' ':'/n'); }#endif	/* enable vulnerability countermeasure for CBC ciphers with	 * known-IV problem (http://www.openssl.org/~bodo/tls-cbc.txt) */	s->s3->need_empty_fragments = 1;#ifndef NO_RC4	if ((s->session->cipher != NULL) && ((s->session->cipher->algorithms & SSL_ENC_MASK) == SSL_RC4))		s->s3->need_empty_fragments = 0;#endif			return(1);err:	SSLerr(SSL_F_TLS1_SETUP_KEY_BLOCK,ERR_R_MALLOC_FAILURE);	return(0);	}

//.........这里部分代码省略.........			if (ret <= 0)				goto end;			s->state = SSL3_ST_SW_FINISHED_A;			s->init_num = 0;			if (!s->method->ssl3_enc->change_cipher_state(s,				SSL3_CHANGE_CIPHER_SERVER_WRITE)) {				ret = -1;				goto end;			}			dtls1_reset_seq_numbers(s, SSL3_CC_WRITE);			break;		case SSL3_ST_SW_FINISHED_A:		case SSL3_ST_SW_FINISHED_B:			ret = dtls1_send_finished(s,			    SSL3_ST_SW_FINISHED_A, SSL3_ST_SW_FINISHED_B,			    s->method->ssl3_enc->server_finished_label,			    s->method->ssl3_enc->server_finished_label_len);			if (ret <= 0)				goto end;			s->state = SSL3_ST_SW_FLUSH;			if (s->hit) {				s->s3->tmp.next_state = SSL3_ST_SR_FINISHED_A;			} else {				s->s3->tmp.next_state = SSL_ST_OK;			}			s->init_num = 0;			break;		case SSL_ST_OK:			/* clean a few things up */			ssl3_cleanup_key_block(s);			/* remove buffering on output */			ssl_free_wbio_buffer(s);			s->init_num = 0;			if (s->renegotiate == 2) /* skipped if we just sent a HelloRequest */			{				s->renegotiate = 0;				s->new_session = 0;				ssl_update_cache(s, SSL_SESS_CACHE_SERVER);				s->ctx->stats.sess_accept_good++;				/* s->server=1; */				s->handshake_func = dtls1_accept;				if (cb != NULL)					cb(s, SSL_CB_HANDSHAKE_DONE, 1);			}			ret = 1;			/* done handshaking, next message is client hello */			s->d1->handshake_read_seq = 0;			/* next message is server hello */			s->d1->handshake_write_seq = 0;			s->d1->next_handshake_write_seq = 0;			goto end;			/* break; */		default:			SSLerr(SSL_F_DTLS1_ACCEPT, SSL_R_UNKNOWN_STATE);			ret = -1;			goto end;			/* break; */		}		if (!s->s3->tmp.reuse_message && !skip) {			if (s->debug) {				if ((ret = BIO_flush(s->wbio)) <= 0)					goto end;			}			if ((cb != NULL) && (s->state != state)) {				new_state = s->state;				s->state = state;				cb(s, SSL_CB_ACCEPT_LOOP, 1);				s->state = new_state;			}		}		skip = 0;	}end:	/* BIO_flush(s->wbio); */	s->in_handshake--;	if (cb != NULL)		cb(s, SSL_CB_ACCEPT_EXIT, ret);	return (ret);}

//.........这里部分代码省略.........			s->init_num=0;			if (!s->method->ssl3_enc->change_cipher_state(s,				SSL3_CHANGE_CIPHER_SERVER_WRITE))				{				ret= -1;				goto end;				}			dtls1_reset_seq_numbers(s, SSL3_CC_WRITE);			break;		case SSL3_ST_SW_FINISHED_A:		case SSL3_ST_SW_FINISHED_B:			ret=ssl3_send_finished(s,				SSL3_ST_SW_FINISHED_A,SSL3_ST_SW_FINISHED_B,				s->method->ssl3_enc->server_finished_label,				s->method->ssl3_enc->server_finished_label_len);			if (ret <= 0) goto end;			s->state=SSL3_ST_SW_FLUSH;			if (s->hit)				{				s->s3->tmp.next_state=SSL3_ST_SR_FINISHED_A;				}			else				{				s->s3->tmp.next_state=SSL_ST_OK;				}			s->init_num=0;			break;		case SSL_ST_OK:			/* clean a few things up */			ssl3_cleanup_key_block(s);#if 0			BUF_MEM_free(s->init_buf);			s->init_buf=NULL;#endif			/* remove buffering on output */			ssl_free_wbio_buffer(s);			s->init_num=0;			if (s->renegotiate == 2) /* skipped if we just sent a HelloRequest */				{				s->renegotiate=0;				s->new_session=0;								ssl_update_cache(s,SSL_SESS_CACHE_SERVER);								s->ctx->stats.sess_accept_good++;				/* s->server=1; */				s->handshake_func=dtls1_accept;				if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);				}						ret = 1;			/* done handshaking, next message is client hello */			s->d1->handshake_read_seq = 0;			/* next message is server hello */			s->d1->handshake_write_seq = 0;			s->d1->next_handshake_write_seq = 0;

int ssl3_setup_key_block(SSL *s){    unsigned char *p;    const EVP_CIPHER *c;    const EVP_MD *hash;    int num;    int ret = 0;    SSL_COMP *comp;    if (s->s3->tmp.key_block_length != 0)        return 1;    if (!ssl_cipher_get_evp(s->session, &c, &hash, NULL, NULL, &comp, 0)) {        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_SETUP_KEY_BLOCK,                 SSL_R_CIPHER_OR_HASH_UNAVAILABLE);        return 0;    }    s->s3->tmp.new_sym_enc = c;    s->s3->tmp.new_hash = hash;#ifdef OPENSSL_NO_COMP    s->s3->tmp.new_compression = NULL;#else    s->s3->tmp.new_compression = comp;#endif    num = EVP_MD_size(hash);    if (num < 0)        return 0;    num = EVP_CIPHER_key_length(c) + num + EVP_CIPHER_iv_length(c);    num *= 2;    ssl3_cleanup_key_block(s);    if ((p = OPENSSL_malloc(num)) == NULL) {        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_SETUP_KEY_BLOCK,                 ERR_R_MALLOC_FAILURE);        return 0;    }    s->s3->tmp.key_block_length = num;    s->s3->tmp.key_block = p;    /* Calls SSLfatal() as required */    ret = ssl3_generate_key_block(s, p, num);    if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)) {        /*         * enable vulnerability countermeasure for CBC ciphers with known-IV         * problem (http://www.openssl.org/~bodo/tls-cbc.txt)         */        s->s3->need_empty_fragments = 1;        if (s->session->cipher != NULL) {            if (s->session->cipher->algorithm_enc == SSL_eNULL)                s->s3->need_empty_fragments = 0;#ifndef OPENSSL_NO_RC4            if (s->session->cipher->algorithm_enc == SSL_RC4)                s->s3->need_empty_fragments = 0;#endif        }    }    return ret;}