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

static int tls_write_client_change_cipher_spec(struct tlsv1_client *conn,					       u8 **msgpos, u8 *end){	size_t rlen;	u8 payload[1];	wpa_printf(MSG_DEBUG, "TLSv1: Send ChangeCipherSpec");	payload[0] = TLS_CHANGE_CIPHER_SPEC;	if (tlsv1_record_send(&conn->rl, TLS_CONTENT_TYPE_CHANGE_CIPHER_SPEC,			      *msgpos, end - *msgpos, payload, sizeof(payload),			      &rlen) < 0) {		wpa_printf(MSG_DEBUG, "TLSv1: Failed to create a record");		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		return -1;	}	if (tlsv1_record_change_write_cipher(&conn->rl) < 0) {		wpa_printf(MSG_DEBUG, "TLSv1: Failed to set write cipher for "			   "record layer");		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		return -1;	}	*msgpos += rlen;	return 0;}

static int tls_process_server_hello_done(struct tlsv1_client *conn, u8 ct,					 const u8 *in_data, size_t *in_len){	const u8 *pos, *end;	size_t left, len;	u8 type;	if (ct != TLS_CONTENT_TYPE_HANDSHAKE) {		wpa_printf(MSG_DEBUG, "TLSv1: Expected Handshake; "			   "received content type 0x%x", ct);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	pos = in_data;	left = *in_len;	if (left < 4) {		wpa_printf(MSG_DEBUG, "TLSv1: Too short ServerHelloDone "			   "(left=%lu)", (unsigned long) left);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL, TLS_ALERT_DECODE_ERROR);		return -1;	}	type = *pos++;	len = WPA_GET_BE24(pos);	pos += 3;	left -= 4;	if (len > left) {		wpa_printf(MSG_DEBUG, "TLSv1: Mismatch in ServerHelloDone "			   "length (len=%lu != left=%lu)",			   (unsigned long) len, (unsigned long) left);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL, TLS_ALERT_DECODE_ERROR);		return -1;	}	end = pos + len;	if (type != TLS_HANDSHAKE_TYPE_SERVER_HELLO_DONE) {		wpa_printf(MSG_DEBUG, "TLSv1: Received unexpected handshake "			   "message %d (expected ServerHelloDone)", type);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	wpa_printf(MSG_DEBUG, "TLSv1: Received ServerHelloDone");	*in_len = end - in_data;	conn->state = CLIENT_KEY_EXCHANGE;	return 0;}

static int tls_process_application_data(struct tlsv1_client *conn, u8 ct,					const u8 *in_data, size_t *in_len,					u8 **out_data, size_t *out_len){	const u8 *pos;	size_t left;	if (ct != TLS_CONTENT_TYPE_APPLICATION_DATA) {		wpa_printf(MSG_DEBUG, "TLSv1: Expected Application Data; "			   "received content type 0x%x", ct);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	pos = in_data;	left = *in_len;	wpa_hexdump(MSG_DEBUG, "TLSv1: Application Data included in Handshake",		    pos, left);	*out_data = os_malloc(left);	if (*out_data) {		os_memcpy(*out_data, pos, left);		*out_len = left;	}	return 0;}

/** * tlsv1_client_decrypt - Decrypt data from TLS tunnel * @conn: TLSv1 client connection data from tlsv1_client_init() * @in_data: Pointer to input buffer (encrypted TLS data) * @in_len: Input buffer length * @out_data: Pointer to output buffer (decrypted data from TLS tunnel) * @out_len: Maximum out_data length * Returns: Number of bytes written to out_data, -1 on failure * * This function is used after TLS handshake has been completed successfully to * receive data from the encrypted tunnel. */int tlsv1_client_decrypt(struct tlsv1_client *conn,			 const u8 *in_data, size_t in_len,			 u8 *out_data, size_t out_len){	const u8 *in_end, *pos;	int res;	u8 alert, *out_end, *out_pos;	size_t olen;	pos = in_data;	in_end = in_data + in_len;	out_pos = out_data;	out_end = out_data + out_len;	while (pos < in_end) {		if (pos[0] != TLS_CONTENT_TYPE_APPLICATION_DATA) {			wpa_printf(MSG_DEBUG, "TLSv1: Unexpected content type "				   "0x%x", pos[0]);			tls_alert(conn, TLS_ALERT_LEVEL_FATAL,				  TLS_ALERT_UNEXPECTED_MESSAGE);			return -1;		}		olen = out_end - out_pos;		res = tlsv1_record_receive(&conn->rl, pos, in_end - pos,					   out_pos, &olen, &alert);		if (res < 0) {			wpa_printf(MSG_DEBUG, "TLSv1: Record layer processing "				   "failed");			tls_alert(conn, TLS_ALERT_LEVEL_FATAL, alert);			return -1;		}		out_pos += olen;		if (out_pos > out_end) {			wpa_printf(MSG_DEBUG, "TLSv1: Buffer not large enough "				   "for processing the received record");			tls_alert(conn, TLS_ALERT_LEVEL_FATAL,				  TLS_ALERT_INTERNAL_ERROR);			return -1;		}		pos += TLS_RECORD_HEADER_LEN + WPA_GET_BE16(pos + 3);	}	return out_pos - out_data;}

static int tls_write_client_key_exchange(struct tlsv1_client *conn,					 u8 **msgpos, u8 *end){	u8 *pos, *rhdr, *hs_start, *hs_length;	size_t rlen;	tls_key_exchange keyx;	const struct tls_cipher_suite *suite;	suite = tls_get_cipher_suite(conn->rl.cipher_suite);	if (suite == NULL)		keyx = TLS_KEY_X_NULL;	else		keyx = suite->key_exchange;	pos = *msgpos;	wpa_printf(MSG_DEBUG, "TLSv1: Send ClientKeyExchange");	rhdr = pos;	pos += TLS_RECORD_HEADER_LEN;	/* opaque fragment[TLSPlaintext.length] */	/* Handshake */	hs_start = pos;	/* HandshakeType msg_type */	*pos++ = TLS_HANDSHAKE_TYPE_CLIENT_KEY_EXCHANGE;	/* uint24 length (to be filled) */	hs_length = pos;	pos += 3;	/* body - ClientKeyExchange */	if (keyx == TLS_KEY_X_DH_anon) {		if (tlsv1_key_x_anon_dh(conn, &pos, end) < 0)			return -1;	} else {		if (tlsv1_key_x_rsa(conn, &pos, end) < 0)			return -1;	}	WPA_PUT_BE24(hs_length, pos - hs_length - 3);	if (tlsv1_record_send(&conn->rl, TLS_CONTENT_TYPE_HANDSHAKE,			      rhdr, end - rhdr, hs_start, pos - hs_start,			      &rlen) < 0) {		wpa_printf(MSG_DEBUG, "TLSv1: Failed to create a record");		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		return -1;	}	pos = rhdr + rlen;	tls_verify_hash_add(&conn->verify, hs_start, pos - hs_start);	*msgpos = pos;	return 0;}

/** * tlsv1_client_encrypt - Encrypt data into TLS tunnel * @conn: TLSv1 client connection data from tlsv1_client_init() * @in_data: Pointer to plaintext data to be encrypted * @in_len: Input buffer length * @out_data: Pointer to output buffer (encrypted TLS data) * @out_len: Maximum out_data length  * Returns: Number of bytes written to out_data, -1 on failure * * This function is used after TLS handshake has been completed successfully to * send data in the encrypted tunnel. */int tlsv1_client_encrypt(struct tlsv1_client *conn,			 const u8 *in_data, size_t in_len,			 u8 *out_data, size_t out_len){	size_t rlen;	wpa_hexdump_key(MSG_MSGDUMP, "TLSv1: Plaintext AppData",			in_data, in_len);	if (tlsv1_record_send(&conn->rl, TLS_CONTENT_TYPE_APPLICATION_DATA,			      out_data, out_len, in_data, in_len, &rlen) < 0) {		wpa_printf(MSG_DEBUG, "TLSv1: Failed to create a record");		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		return -1;	}	return rlen;}

static int tls_process_server_finished(struct tlsv1_client *conn, u8 ct,				       const u8 *in_data, size_t *in_len){	const u8 *pos, *end;	size_t left, len, hlen;	u8 verify_data[TLS_VERIFY_DATA_LEN];	u8 hash[MD5_MAC_LEN + SHA1_MAC_LEN];	if (ct != TLS_CONTENT_TYPE_HANDSHAKE) {		wpa_printf(MSG_DEBUG, "TLSv1: Expected Finished; "			   "received content type 0x%x", ct);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	pos = in_data;	left = *in_len;	if (left < 4) {		wpa_printf(MSG_DEBUG, "TLSv1: Too short record (left=%lu) for "			   "Finished",			   (unsigned long) left);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_DECODE_ERROR);		return -1;	}	if (pos[0] != TLS_HANDSHAKE_TYPE_FINISHED) {		wpa_printf(MSG_DEBUG, "TLSv1: Expected Finished; received "			   "type 0x%x", pos[0]);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	len = WPA_GET_BE24(pos + 1);	pos += 4;	left -= 4;	if (len > left) {		wpa_printf(MSG_DEBUG, "TLSv1: Too short buffer for Finished "			   "(len=%lu > left=%lu)",			   (unsigned long) len, (unsigned long) left);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_DECODE_ERROR);		return -1;	}	end = pos + len;	if (len != TLS_VERIFY_DATA_LEN) {		wpa_printf(MSG_DEBUG, "TLSv1: Unexpected verify_data length "			   "in Finished: %lu (expected %d)",			   (unsigned long) len, TLS_VERIFY_DATA_LEN);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_DECODE_ERROR);		return -1;	}	wpa_hexdump(MSG_MSGDUMP, "TLSv1: verify_data in Finished",		    pos, TLS_VERIFY_DATA_LEN);#ifdef CONFIG_TLSV12	if (conn->rl.tls_version >= TLS_VERSION_1_2) {		hlen = SHA256_MAC_LEN;		if (conn->verify.sha256_server == NULL ||		    crypto_hash_finish(conn->verify.sha256_server, hash, &hlen)		    < 0) {			tls_alert(conn, TLS_ALERT_LEVEL_FATAL,				  TLS_ALERT_INTERNAL_ERROR);			conn->verify.sha256_server = NULL;			return -1;		}		conn->verify.sha256_server = NULL;	} else {#endif /* CONFIG_TLSV12 */	hlen = MD5_MAC_LEN;	if (conn->verify.md5_server == NULL ||	    crypto_hash_finish(conn->verify.md5_server, hash, &hlen) < 0) {		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		conn->verify.md5_server = NULL;		crypto_hash_finish(conn->verify.sha1_server, NULL, NULL);		conn->verify.sha1_server = NULL;		return -1;	}	conn->verify.md5_server = NULL;	hlen = SHA1_MAC_LEN;	if (conn->verify.sha1_server == NULL ||	    crypto_hash_finish(conn->verify.sha1_server, hash + MD5_MAC_LEN,			       &hlen) < 0) {		conn->verify.sha1_server = NULL;		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		return -1;	}	conn->verify.sha1_server = NULL;	hlen = MD5_MAC_LEN + SHA1_MAC_LEN;#ifdef CONFIG_TLSV12//.........这里部分代码省略.........

static int tls_write_client_finished(struct tlsv1_client *conn,				     u8 **msgpos, u8 *end){	u8 *pos, *hs_start;	size_t rlen, hlen;	u8 verify_data[1 + 3 + TLS_VERIFY_DATA_LEN];	u8 hash[MD5_MAC_LEN + SHA1_MAC_LEN];	wpa_printf(MSG_DEBUG, "TLSv1: Send Finished");	/* Encrypted Handshake Message: Finished */	hlen = MD5_MAC_LEN;	if (conn->verify.md5_client == NULL ||	    crypto_hash_finish(conn->verify.md5_client, hash, &hlen) < 0) {		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		conn->verify.md5_client = NULL;		crypto_hash_finish(conn->verify.sha1_client, NULL, NULL);		conn->verify.sha1_client = NULL;		return -1;	}	conn->verify.md5_client = NULL;	hlen = SHA1_MAC_LEN;	if (conn->verify.sha1_client == NULL ||	    crypto_hash_finish(conn->verify.sha1_client, hash + MD5_MAC_LEN,			       &hlen) < 0) {		conn->verify.sha1_client = NULL;		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		return -1;	}	conn->verify.sha1_client = NULL;	if (tls_prf(conn->master_secret, TLS_MASTER_SECRET_LEN,		    "client finished", hash, MD5_MAC_LEN + SHA1_MAC_LEN,		    verify_data + 1 + 3, TLS_VERIFY_DATA_LEN)) {		wpa_printf(MSG_DEBUG, "TLSv1: Failed to generate verify_data");		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		return -1;	}	wpa_hexdump_key(MSG_DEBUG, "TLSv1: verify_data (client)",			verify_data + 1 + 3, TLS_VERIFY_DATA_LEN);	/* Handshake */	pos = hs_start = verify_data;	/* HandshakeType msg_type */	*pos++ = TLS_HANDSHAKE_TYPE_FINISHED;	/* uint24 length */	WPA_PUT_BE24(pos, TLS_VERIFY_DATA_LEN);	pos += 3;	pos += TLS_VERIFY_DATA_LEN; /* verify_data already in place */	tls_verify_hash_add(&conn->verify, hs_start, pos - hs_start);	if (tlsv1_record_send(&conn->rl, TLS_CONTENT_TYPE_HANDSHAKE,			      *msgpos, end - *msgpos, hs_start, pos - hs_start,			      &rlen) < 0) {		wpa_printf(MSG_DEBUG, "TLSv1: Failed to create a record");		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		return -1;	}	*msgpos += rlen;	return 0;}

/** * tlsv1_client_handshake - Process TLS handshake * @conn: TLSv1 client connection data from tlsv1_client_init() * @in_data: Input data from TLS peer * @in_len: Input data length * @out_len: Length of the output buffer. * @appl_data: Pointer to application data pointer, or %NULL if dropped * @appl_data_len: Pointer to variable that is set to appl_data length * Returns: Pointer to output data, %NULL on failure */u8 * tlsv1_client_handshake(struct tlsv1_client *conn,			    const u8 *in_data, size_t in_len,			    size_t *out_len, u8 **appl_data,			    size_t *appl_data_len){	const u8 *pos, *end;	u8 *msg = NULL, *in_msg, *in_pos, *in_end, alert, ct;	size_t in_msg_len;	int no_appl_data;	if (conn->state == CLIENT_HELLO) {		if (in_len)			return NULL;		return tls_send_client_hello(conn, out_len);	}	if (in_data == NULL || in_len == 0)		return NULL;	pos = in_data;	end = in_data + in_len;	in_msg = os_malloc(in_len);	if (in_msg == NULL)		return NULL;	/* Each received packet may include multiple records */	while (pos < end) {		in_msg_len = in_len;		if (tlsv1_record_receive(&conn->rl, pos, end - pos,					 in_msg, &in_msg_len, &alert)) {			wpa_printf(MSG_DEBUG, "TLSv1: Processing received "				   "record failed");			tls_alert(conn, TLS_ALERT_LEVEL_FATAL, alert);			goto failed;		}		ct = pos[0];		in_pos = in_msg;		in_end = in_msg + in_msg_len;		/* Each received record may include multiple messages of the		 * same ContentType. */		while (in_pos < in_end) {			in_msg_len = in_end - in_pos;			if (tlsv1_client_process_handshake(conn, ct, in_pos,							   &in_msg_len,							   appl_data,							   appl_data_len) < 0)				goto failed;			in_pos += in_msg_len;		}		pos += TLS_RECORD_HEADER_LEN + WPA_GET_BE16(pos + 3);	}	os_free(in_msg);	in_msg = NULL;	no_appl_data = appl_data == NULL || *appl_data == NULL;	msg = tlsv1_client_handshake_write(conn, out_len, no_appl_data);failed:	os_free(in_msg);	if (conn->alert_level) {		conn->state = FAILED;		os_free(msg);		msg = tlsv1_client_send_alert(conn, conn->alert_level,					      conn->alert_description,					      out_len);	} else if (msg == NULL) {		msg = os_zalloc(1);		*out_len = 0;	}	return msg;}

//.........这里部分代码省略.........	const u8 *in_end, *pos;	int used;	u8 alert, *out_pos, ct;	size_t olen;	struct wpabuf *buf = NULL;	if (need_more_data)		*need_more_data = 0;	if (conn->partial_input) {		if (wpabuf_resize(&conn->partial_input, in_len) < 0) {			wpa_printf(MSG_DEBUG, "TLSv1: Failed to allocate "				   "memory for pending record");			alert = TLS_ALERT_INTERNAL_ERROR;			goto fail;		}		wpabuf_put_data(conn->partial_input, in_data, in_len);		in_data = wpabuf_head(conn->partial_input);		in_len = wpabuf_len(conn->partial_input);	}	pos = in_data;	in_end = in_data + in_len;	while (pos < in_end) {		ct = pos[0];		if (wpabuf_resize(&buf, in_end - pos) < 0) {			alert = TLS_ALERT_INTERNAL_ERROR;			goto fail;		}		out_pos = wpabuf_put(buf, 0);		olen = wpabuf_tailroom(buf);		used = tlsv1_record_receive(&conn->rl, pos, in_end - pos,					    out_pos, &olen, &alert);		if (used < 0) {			wpa_printf(MSG_DEBUG, "TLSv1: Record layer processing "				   "failed");			goto fail;		}		if (used == 0) {			struct wpabuf *partial;			wpa_printf(MSG_DEBUG, "TLSv1: Need more data");			partial = wpabuf_alloc_copy(pos, in_end - pos);			wpabuf_free(conn->partial_input);			conn->partial_input = partial;			if (conn->partial_input == NULL) {				wpa_printf(MSG_DEBUG, "TLSv1: Failed to "					   "allocate memory for pending "					   "record");				alert = TLS_ALERT_INTERNAL_ERROR;				goto fail;			}			if (need_more_data)				*need_more_data = 1;			return buf;		}		if (ct == TLS_CONTENT_TYPE_ALERT) {			if (olen < 2) {				wpa_printf(MSG_DEBUG, "TLSv1: Alert "					   "underflow");				alert = TLS_ALERT_DECODE_ERROR;				goto fail;			}			wpa_printf(MSG_DEBUG, "TLSv1: Received alert %d:%d",				   out_pos[0], out_pos[1]);			if (out_pos[0] == TLS_ALERT_LEVEL_WARNING) {				/* Continue processing */				pos += used;				continue;			}			alert = out_pos[1];			goto fail;		}		if (ct != TLS_CONTENT_TYPE_APPLICATION_DATA) {			wpa_printf(MSG_DEBUG, "TLSv1: Unexpected content type "				   "0x%x when decrypting application data",				   pos[0]);			alert = TLS_ALERT_UNEXPECTED_MESSAGE;			goto fail;		}		wpabuf_put(buf, olen);		pos += used;	}	wpabuf_free(conn->partial_input);	conn->partial_input = NULL;	return buf;fail:	wpabuf_free(buf);	wpabuf_free(conn->partial_input);	conn->partial_input = NULL;	tls_alert(conn, TLS_ALERT_LEVEL_FATAL, alert);	return NULL;}

int tlsv1_client_process_handshake(struct tlsv1_client *conn, u8 ct,				   const u8 *buf, size_t *len,				   u8 **out_data, size_t *out_len){	if (ct == TLS_CONTENT_TYPE_ALERT) {		if (*len < 2) {			wpa_printf(MSG_DEBUG, "TLSv1: Alert underflow");			tls_alert(conn, TLS_ALERT_LEVEL_FATAL,				  TLS_ALERT_DECODE_ERROR);			return -1;		}		wpa_printf(MSG_DEBUG, "TLSv1: Received alert %d:%d",			   buf[0], buf[1]);		*len = 2;		conn->state = FAILED;		return -1;	}	if (ct == TLS_CONTENT_TYPE_HANDSHAKE && *len >= 4 &&	    buf[0] == TLS_HANDSHAKE_TYPE_HELLO_REQUEST) {		size_t hr_len = WPA_GET_BE24(buf + 1);		if (hr_len > *len - 4) {			wpa_printf(MSG_DEBUG, "TLSv1: HelloRequest underflow");			tls_alert(conn, TLS_ALERT_LEVEL_FATAL,				  TLS_ALERT_DECODE_ERROR);			return -1;		}		wpa_printf(MSG_DEBUG, "TLSv1: Ignored HelloRequest");		*len = 4 + hr_len;		return 0;	}	switch (conn->state) {	case SERVER_HELLO:		if (tls_process_server_hello(conn, ct, buf, len))			return -1;		break;	case SERVER_CERTIFICATE:		if (tls_process_certificate(conn, ct, buf, len))			return -1;		break;	case SERVER_KEY_EXCHANGE:		if (tls_process_server_key_exchange(conn, ct, buf, len))			return -1;		break;	case SERVER_CERTIFICATE_REQUEST:		if (tls_process_certificate_request(conn, ct, buf, len))			return -1;		break;	case SERVER_HELLO_DONE:		if (tls_process_server_hello_done(conn, ct, buf, len))			return -1;		break;	case SERVER_CHANGE_CIPHER_SPEC:		if (tls_process_server_change_cipher_spec(conn, ct, buf, len))			return -1;		break;	case SERVER_FINISHED:		if (tls_process_server_finished(conn, ct, buf, len))			return -1;		break;	case ACK_FINISHED:		if (out_data &&		    tls_process_application_data(conn, ct, buf, len, out_data,						 out_len))			return -1;		break;	default:		wpa_printf(MSG_DEBUG, "TLSv1: Unexpected state %d "			   "while processing received message",			   conn->state);		return -1;	}	if (ct == TLS_CONTENT_TYPE_HANDSHAKE)		tls_verify_hash_add(&conn->verify, buf, *len);	return 0;}

static int tls_process_server_change_cipher_spec(struct tlsv1_client *conn,						 u8 ct, const u8 *in_data,						 size_t *in_len){	const u8 *pos;	size_t left;	if (ct != TLS_CONTENT_TYPE_CHANGE_CIPHER_SPEC) {		wpa_printf(MSG_DEBUG, "TLSv1: Expected ChangeCipherSpec; "			   "received content type 0x%x", ct);		if (conn->use_session_ticket) {			int res;			wpa_printf(MSG_DEBUG, "TLSv1: Server may have "				   "rejected SessionTicket");			conn->use_session_ticket = 0;			/* Notify upper layers that SessionTicket failed */			res = conn->session_ticket_cb(				conn->session_ticket_cb_ctx, NULL, 0, NULL,				NULL, NULL);			if (res < 0) {				wpa_printf(MSG_DEBUG, "TLSv1: SessionTicket "					   "callback indicated failure");				tls_alert(conn, TLS_ALERT_LEVEL_FATAL,					  TLS_ALERT_HANDSHAKE_FAILURE);				return -1;			}			conn->state = SERVER_CERTIFICATE;			return tls_process_certificate(conn, ct, in_data,						       in_len);		}		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	pos = in_data;	left = *in_len;	if (left < 1) {		wpa_printf(MSG_DEBUG, "TLSv1: Too short ChangeCipherSpec");		tls_alert(conn, TLS_ALERT_LEVEL_FATAL, TLS_ALERT_DECODE_ERROR);		return -1;	}	if (*pos != TLS_CHANGE_CIPHER_SPEC) {		wpa_printf(MSG_DEBUG, "TLSv1: Expected ChangeCipherSpec; "			   "received data 0x%x", *pos);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	wpa_printf(MSG_DEBUG, "TLSv1: Received ChangeCipherSpec");	if (tlsv1_record_change_read_cipher(&conn->rl) < 0) {		wpa_printf(MSG_DEBUG, "TLSv1: Failed to change read cipher "			   "for record layer");		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_INTERNAL_ERROR);		return -1;	}	*in_len = pos + 1 - in_data;	conn->state = SERVER_FINISHED;	return 0;}

static int tls_process_certificate(struct tlsv1_client *conn, u8 ct,				   const u8 *in_data, size_t *in_len){	const u8 *pos, *end;	size_t left, len, list_len, cert_len, idx;	u8 type;	struct x509_certificate *chain = NULL, *last = NULL, *cert;	int reason;	if (ct != TLS_CONTENT_TYPE_HANDSHAKE) {		wpa_printf(MSG_DEBUG, "TLSv1: Expected Handshake; "			   "received content type 0x%x", ct);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	pos = in_data;	left = *in_len;	if (left < 4) {		wpa_printf(MSG_DEBUG, "TLSv1: Too short Certificate message "			   "(len=%lu)", (unsigned long) left);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL, TLS_ALERT_DECODE_ERROR);		return -1;	}	type = *pos++;	len = WPA_GET_BE24(pos);	pos += 3;	left -= 4;	if (len > left) {		wpa_printf(MSG_DEBUG, "TLSv1: Unexpected Certificate message "			   "length (len=%lu != left=%lu)",			   (unsigned long) len, (unsigned long) left);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL, TLS_ALERT_DECODE_ERROR);		return -1;	}	if (type == TLS_HANDSHAKE_TYPE_SERVER_KEY_EXCHANGE)		return tls_process_server_key_exchange(conn, ct, in_data,						       in_len);	if (type == TLS_HANDSHAKE_TYPE_CERTIFICATE_REQUEST)		return tls_process_certificate_request(conn, ct, in_data,						       in_len);	if (type == TLS_HANDSHAKE_TYPE_SERVER_HELLO_DONE)		return tls_process_server_hello_done(conn, ct, in_data,						     in_len);	if (type != TLS_HANDSHAKE_TYPE_CERTIFICATE) {		wpa_printf(MSG_DEBUG, "TLSv1: Received unexpected handshake "			   "message %d (expected Certificate/"			   "ServerKeyExchange/CertificateRequest/"			   "ServerHelloDone)", type);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	wpa_printf(MSG_DEBUG,		   "TLSv1: Received Certificate (certificate_list len %lu)",		   (unsigned long) len);	/*	 * opaque ASN.1Cert<2^24-1>;	 *	 * struct {	 *     ASN.1Cert certificate_list<1..2^24-1>;	 * } Certificate;	 */	end = pos + len;	if (end - pos < 3) {		wpa_printf(MSG_DEBUG, "TLSv1: Too short Certificate "			   "(left=%lu)", (unsigned long) left);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL, TLS_ALERT_DECODE_ERROR);		return -1;	}	list_len = WPA_GET_BE24(pos);	pos += 3;	if ((size_t) (end - pos) != list_len) {		wpa_printf(MSG_DEBUG, "TLSv1: Unexpected certificate_list "			   "length (len=%lu left=%lu)",			   (unsigned long) list_len,			   (unsigned long) (end - pos));		tls_alert(conn, TLS_ALERT_LEVEL_FATAL, TLS_ALERT_DECODE_ERROR);		return -1;	}	idx = 0;	while (pos < end) {		if (end - pos < 3) {			wpa_printf(MSG_DEBUG, "TLSv1: Failed to parse "				   "certificate_list");			tls_alert(conn, TLS_ALERT_LEVEL_FATAL,				  TLS_ALERT_DECODE_ERROR);			x509_certificate_chain_free(chain);//.........这里部分代码省略.........

static int tls_process_server_key_exchange(struct tlsv1_client *conn, u8 ct,					   const u8 *in_data, size_t *in_len){	const u8 *pos, *end;	size_t left, len;	u8 type;	const struct tls_cipher_suite *suite;	if (ct != TLS_CONTENT_TYPE_HANDSHAKE) {		wpa_printf(MSG_DEBUG, "TLSv1: Expected Handshake; "			   "received content type 0x%x", ct);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	pos = in_data;	left = *in_len;	if (left < 4) {		wpa_printf(MSG_DEBUG, "TLSv1: Too short ServerKeyExchange "			   "(Left=%lu)", (unsigned long) left);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL, TLS_ALERT_DECODE_ERROR);		return -1;	}	type = *pos++;	len = WPA_GET_BE24(pos);	pos += 3;	left -= 4;	if (len > left) {		wpa_printf(MSG_DEBUG, "TLSv1: Mismatch in ServerKeyExchange "			   "length (len=%lu != left=%lu)",			   (unsigned long) len, (unsigned long) left);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL, TLS_ALERT_DECODE_ERROR);		return -1;	}	end = pos + len;	if (type == TLS_HANDSHAKE_TYPE_CERTIFICATE_REQUEST)		return tls_process_certificate_request(conn, ct, in_data,						       in_len);	if (type == TLS_HANDSHAKE_TYPE_SERVER_HELLO_DONE)		return tls_process_server_hello_done(conn, ct, in_data,						     in_len);	if (type != TLS_HANDSHAKE_TYPE_SERVER_KEY_EXCHANGE) {		wpa_printf(MSG_DEBUG, "TLSv1: Received unexpected handshake "			   "message %d (expected ServerKeyExchange/"			   "CertificateRequest/ServerHelloDone)", type);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	wpa_printf(MSG_DEBUG, "TLSv1: Received ServerKeyExchange");	if (!tls_server_key_exchange_allowed(conn->rl.cipher_suite)) {		wpa_printf(MSG_DEBUG, "TLSv1: ServerKeyExchange not allowed "			   "with the selected cipher suite");		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	wpa_hexdump(MSG_DEBUG, "TLSv1: ServerKeyExchange", pos, len);	suite = tls_get_cipher_suite(conn->rl.cipher_suite);	if (suite && (suite->key_exchange == TLS_KEY_X_DH_anon ||		      suite->key_exchange == TLS_KEY_X_DHE_RSA)) {		if (tlsv1_process_diffie_hellman(conn, pos, len,						 suite->key_exchange) < 0) {			tls_alert(conn, TLS_ALERT_LEVEL_FATAL,				  TLS_ALERT_DECODE_ERROR);			return -1;		}	} else {		wpa_printf(MSG_DEBUG, "TLSv1: UnexpectedServerKeyExchange");		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	*in_len = end - in_data;	conn->state = SERVER_CERTIFICATE_REQUEST;	return 0;}

static int tls_process_server_hello(struct tlsv1_client *conn, u8 ct,				    const u8 *in_data, size_t *in_len){	const u8 *pos, *end;	size_t left, len, i;	u16 cipher_suite;	u16 tls_version;	if (ct != TLS_CONTENT_TYPE_HANDSHAKE) {		wpa_printf(MSG_DEBUG, "TLSv1: Expected Handshake; "			   "received content type 0x%x", ct);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	pos = in_data;	left = *in_len;	if (left < 4)		goto decode_error;	/* HandshakeType msg_type */	if (*pos != TLS_HANDSHAKE_TYPE_SERVER_HELLO) {		wpa_printf(MSG_DEBUG, "TLSv1: Received unexpected handshake "			   "message %d (expected ServerHello)", *pos);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_UNEXPECTED_MESSAGE);		return -1;	}	wpa_printf(MSG_DEBUG, "TLSv1: Received ServerHello");	pos++;	/* uint24 length */	len = WPA_GET_BE24(pos);	pos += 3;	left -= 4;	if (len > left)		goto decode_error;	/* body - ServerHello */	wpa_hexdump(MSG_MSGDUMP, "TLSv1: ServerHello", pos, len);	end = pos + len;	/* ProtocolVersion server_version */	if (end - pos < 2)		goto decode_error;	tls_version = WPA_GET_BE16(pos);	if (!tls_version_ok(tls_version)) {		wpa_printf(MSG_DEBUG, "TLSv1: Unexpected protocol version in "			   "ServerHello %u.%u", pos[0], pos[1]);		tls_alert(conn, TLS_ALERT_LEVEL_FATAL,			  TLS_ALERT_PROTOCOL_VERSION);		return -1;	}	pos += 2;	wpa_printf(MSG_DEBUG, "TLSv1: Using TLS v%s",		   tls_version_str(tls_version));	conn->rl.tls_version = tls_version;	/* Random random */	if (end - pos < TLS_RANDOM_LEN)		goto decode_error;	os_memcpy(conn->server_random, pos, TLS_RANDOM_LEN);	pos += TLS_RANDOM_LEN;	wpa_hexdump(MSG_MSGDUMP, "TLSv1: server_random",		    conn->server_random, TLS_RANDOM_LEN);	/* SessionID session_id */	if (end - pos < 1)		goto decode_error;	if (end - pos < 1 + *pos || *pos > TLS_SESSION_ID_MAX_LEN)		goto decode_error;	if (conn->session_id_len && conn->session_id_len == *pos &&	    os_memcmp(conn->session_id, pos + 1, conn->session_id_len) == 0) {		pos += 1 + conn->session_id_len;		wpa_printf(MSG_DEBUG, "TLSv1: Resuming old session");		conn->session_resumed = 1;	} else {		conn->session_id_len = *pos;		pos++;		os_memcpy(conn->session_id, pos, conn->session_id_len);		pos += conn->session_id_len;	}	wpa_hexdump(MSG_MSGDUMP, "TLSv1: session_id",		    conn->session_id, conn->session_id_len);	/* CipherSuite cipher_suite */	if (end - pos < 2)		goto decode_error;	cipher_suite = WPA_GET_BE16(pos);	pos += 2;	for (i = 0; i < conn->num_cipher_suites; i++) {		if (cipher_suite == conn->cipher_suites[i])			break;	}	if (i == conn->num_cipher_suites) {//.........这里部分代码省略.........

/** * tlsv1_client_handshake - Process TLS handshake * @conn: TLSv1 client connection data from tlsv1_client_init() * @in_data: Input data from TLS peer * @in_len: Input data length * @out_len: Length of the output buffer. * @appl_data: Pointer to application data pointer, or %NULL if dropped * @appl_data_len: Pointer to variable that is set to appl_data length * @need_more_data: Set to 1 if more data would be needed to complete *	processing * Returns: Pointer to output data, %NULL on failure */u8 * tlsv1_client_handshake(struct tlsv1_client *conn,			    const u8 *in_data, size_t in_len,			    size_t *out_len, u8 **appl_data,			    size_t *appl_data_len, int *need_more_data){	const u8 *pos, *end;	u8 *msg = NULL, *in_msg = NULL, *in_pos, *in_end, alert, ct;	size_t in_msg_len;	int no_appl_data;	int used;	if (need_more_data)		*need_more_data = 0;	if (conn->state == CLIENT_HELLO) {		if (in_len)			return NULL;		return tls_send_client_hello(conn, out_len);	}	if (conn->partial_input) {		if (wpabuf_resize(&conn->partial_input, in_len) < 0) {			wpa_printf(MSG_DEBUG, "TLSv1: Failed to allocate "				   "memory for pending record");			tls_alert(conn, TLS_ALERT_LEVEL_FATAL,				  TLS_ALERT_INTERNAL_ERROR);			goto failed;		}		wpabuf_put_data(conn->partial_input, in_data, in_len);		in_data = wpabuf_head(conn->partial_input);		in_len = wpabuf_len(conn->partial_input);	}	if (in_data == NULL || in_len == 0)		return NULL;	pos = in_data;	end = in_data + in_len;	in_msg = os_malloc(in_len);	if (in_msg == NULL)		return NULL;	/* Each received packet may include multiple records */	while (pos < end) {		in_msg_len = in_len;		used = tlsv1_record_receive(&conn->rl, pos, end - pos,					    in_msg, &in_msg_len, &alert);		if (used < 0) {			wpa_printf(MSG_DEBUG, "TLSv1: Processing received "				   "record failed");			tls_alert(conn, TLS_ALERT_LEVEL_FATAL, alert);			goto failed;		}		if (used == 0) {			struct wpabuf *partial;			wpa_printf(MSG_DEBUG, "TLSv1: Need more data");			partial = wpabuf_alloc_copy(pos, end - pos);			wpabuf_free(conn->partial_input);			conn->partial_input = partial;			if (conn->partial_input == NULL) {				wpa_printf(MSG_DEBUG, "TLSv1: Failed to "					   "allocate memory for pending "					   "record");				tls_alert(conn, TLS_ALERT_LEVEL_FATAL,					  TLS_ALERT_INTERNAL_ERROR);				goto failed;			}			os_free(in_msg);			if (need_more_data)				*need_more_data = 1;			return NULL;		}		ct = pos[0];		in_pos = in_msg;		in_end = in_msg + in_msg_len;		/* Each received record may include multiple messages of the		 * same ContentType. */		while (in_pos < in_end) {			in_msg_len = in_end - in_pos;			if (tlsv1_client_process_handshake(conn, ct, in_pos,							   &in_msg_len,							   appl_data,							   appl_data_len) < 0)				goto failed;			in_pos += in_msg_len;		}//.........这里部分代码省略.........

static int tls_write_client_certificate_verify(struct tlsv1_client *conn,					       u8 **msgpos, u8 *end){	u8 *pos, *rhdr, *hs_start, *hs_length, *signed_start;	size_t rlen, hlen, clen;	u8 hash[100], *hpos;	enum { SIGN_ALG_RSA, SIGN_ALG_DSA } alg = SIGN_ALG_RSA;	pos = *msgpos;	wpa_printf(MSG_DEBUG, "TLSv1: Send CertificateVerify");	rhdr = pos;	pos += TLS_RECORD_HEADER_LEN;	/* Handshake */	hs_start = pos;	/* HandshakeType msg_type */	*pos++ = TLS_HANDSHAKE_TYPE_CERTIFICATE_VERIFY;	/* uint24 length (to be filled) */	hs_length = pos;	pos += 3;	/*	 * RFC 2246: 7.4.3 and 7.4.8:	 * Signature signature	 *	 * RSA:	 * digitally-signed struct {	 *     opaque md5_hash[16];	 *     opaque sha_hash[20];	 * };	 *	 * DSA:	 * digitally-signed struct {	 *     opaque sha_hash[20];	 * };	 *	 * The hash values are calculated over all handshake messages sent or	 * received starting at ClientHello up to, but not including, this	 * CertificateVerify message, including the type and length fields of	 * the handshake messages.	 */	hpos = hash;#ifdef CONFIG_TLSV12	if (conn->rl.tls_version == TLS_VERSION_1_2) {		hlen = SHA256_MAC_LEN;		if (conn->verify.sha256_cert == NULL ||		    crypto_hash_finish(conn->verify.sha256_cert, hpos, &hlen) <		    0) {			conn->verify.sha256_cert = NULL;			tls_alert(conn, TLS_ALERT_LEVEL_FATAL,				  TLS_ALERT_INTERNAL_ERROR);			return -1;		}		conn->verify.sha256_cert = NULL;		/*		 * RFC 3447, A.2.4 RSASSA-PKCS1-v1_5		 *		 * DigestInfo ::= SEQUENCE {		 *   digestAlgorithm DigestAlgorithm,		 *   digest OCTET STRING		 * }		 *		 * SHA-256 OID: sha256WithRSAEncryption ::= {pkcs-1 11}		 *		 * DER encoded DigestInfo for SHA256 per RFC 3447:		 * 30 31 30 0d 06 09 60 86 48 01 65 03 04 02 01 05 00 04 20 ||		 * H		 */		os_memmove(hash + 19, hash, hlen);		hlen += 19;		os_memcpy(hash, "/x30/x31/x30/x0d/x06/x09/x60/x86/x48/x01/x65"			  "/x03/x04/x02/x01/x05/x00/x04/x20", 19);	} else {#endif /* CONFIG_TLSV12 */	if (alg == SIGN_ALG_RSA) {		hlen = MD5_MAC_LEN;		if (conn->verify.md5_cert == NULL ||		    crypto_hash_finish(conn->verify.md5_cert, hpos, &hlen) < 0)		{			tls_alert(conn, TLS_ALERT_LEVEL_FATAL,				  TLS_ALERT_INTERNAL_ERROR);			conn->verify.md5_cert = NULL;			crypto_hash_finish(conn->verify.sha1_cert, NULL, NULL);			conn->verify.sha1_cert = NULL;			return -1;		}		hpos += MD5_MAC_LEN;	} else		crypto_hash_finish(conn->verify.md5_cert, NULL, NULL);	conn->verify.md5_cert = NULL;	hlen = SHA1_MAC_LEN;	if (conn->verify.sha1_cert == NULL ||	    crypto_hash_finish(conn->verify.sha1_cert, hpos, &hlen) < 0) {		conn->verify.sha1_cert = NULL;//.........这里部分代码省略.........