Lines Matching refs:ssl
279 static uint32_t ssl_get_hs_total_len(mbedtls_ssl_context const *ssl);
285 void mbedtls_ssl_set_timer(mbedtls_ssl_context *ssl, uint32_t millisecs) in mbedtls_ssl_set_timer() argument
287 if (ssl->f_set_timer == NULL) { in mbedtls_ssl_set_timer()
292 ssl->f_set_timer(ssl->p_timer, millisecs / 4, millisecs); in mbedtls_ssl_set_timer()
298 int mbedtls_ssl_check_timer(mbedtls_ssl_context *ssl) in mbedtls_ssl_check_timer() argument
300 if (ssl->f_get_timer == NULL) { in mbedtls_ssl_check_timer()
304 if (ssl->f_get_timer(ssl->p_timer) == 2) { in mbedtls_ssl_check_timer()
313 static int ssl_parse_record_header(mbedtls_ssl_context const *ssl,
318 int mbedtls_ssl_check_record(mbedtls_ssl_context const *ssl, in mbedtls_ssl_check_record() argument
329 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_STREAM) { in mbedtls_ssl_check_record()
337 ret = ssl_parse_record_header(ssl, buf, buflen, &rec); in mbedtls_ssl_check_record()
343 if (ssl->transform_in != NULL) { in mbedtls_ssl_check_record()
344 ret = mbedtls_ssl_decrypt_buf(ssl, ssl->transform_in, &rec); in mbedtls_ssl_check_record()
375 static void ssl_buffering_free_slot(mbedtls_ssl_context *ssl,
377 static void ssl_free_buffered_record(mbedtls_ssl_context *ssl);
379 static int ssl_load_buffered_message(mbedtls_ssl_context *ssl);
381 static int ssl_load_buffered_record(mbedtls_ssl_context *ssl);
383 static int ssl_buffer_message(mbedtls_ssl_context *ssl);
385 static int ssl_buffer_future_record(mbedtls_ssl_context *ssl,
388 static int ssl_next_record_is_in_datagram(mbedtls_ssl_context *ssl);
390 static size_t ssl_get_maximum_datagram_size(mbedtls_ssl_context const *ssl) in ssl_get_maximum_datagram_size() argument
392 size_t mtu = mbedtls_ssl_get_current_mtu(ssl); in ssl_get_maximum_datagram_size()
394 size_t out_buf_len = ssl->out_buf_len; in ssl_get_maximum_datagram_size()
407 static int ssl_get_remaining_space_in_datagram(mbedtls_ssl_context const *ssl) in ssl_get_remaining_space_in_datagram() argument
409 size_t const bytes_written = ssl->out_left; in ssl_get_remaining_space_in_datagram()
410 size_t const mtu = ssl_get_maximum_datagram_size(ssl); in ssl_get_remaining_space_in_datagram()
423 static int ssl_get_remaining_payload_in_datagram(mbedtls_ssl_context const *ssl) in ssl_get_remaining_payload_in_datagram() argument
430 const size_t mfl = mbedtls_ssl_get_output_max_frag_len(ssl); in ssl_get_remaining_payload_in_datagram()
445 if (max_len <= ssl->out_left) { in ssl_get_remaining_payload_in_datagram()
449 max_len -= ssl->out_left; in ssl_get_remaining_payload_in_datagram()
452 ret = ssl_get_remaining_space_in_datagram(ssl); in ssl_get_remaining_payload_in_datagram()
458 ret = mbedtls_ssl_get_record_expansion(ssl); in ssl_get_remaining_payload_in_datagram()
481 static int ssl_double_retransmit_timeout(mbedtls_ssl_context *ssl) in ssl_double_retransmit_timeout() argument
485 if (ssl->handshake->retransmit_timeout >= ssl->conf->hs_timeout_max) { in ssl_double_retransmit_timeout()
495 if (ssl->handshake->retransmit_timeout != ssl->conf->hs_timeout_min) { in ssl_double_retransmit_timeout()
496 ssl->handshake->mtu = 508; in ssl_double_retransmit_timeout()
497 MBEDTLS_SSL_DEBUG_MSG(2, ("mtu autoreduction to %d bytes", ssl->handshake->mtu)); in ssl_double_retransmit_timeout()
500 new_timeout = 2 * ssl->handshake->retransmit_timeout; in ssl_double_retransmit_timeout()
503 if (new_timeout < ssl->handshake->retransmit_timeout || in ssl_double_retransmit_timeout()
504 new_timeout > ssl->conf->hs_timeout_max) { in ssl_double_retransmit_timeout()
505 new_timeout = ssl->conf->hs_timeout_max; in ssl_double_retransmit_timeout()
508 ssl->handshake->retransmit_timeout = new_timeout; in ssl_double_retransmit_timeout()
510 (unsigned long) ssl->handshake->retransmit_timeout)); in ssl_double_retransmit_timeout()
515 static void ssl_reset_retransmit_timeout(mbedtls_ssl_context *ssl) in ssl_reset_retransmit_timeout() argument
517 ssl->handshake->retransmit_timeout = ssl->conf->hs_timeout_min; in ssl_reset_retransmit_timeout()
519 (unsigned long) ssl->handshake->retransmit_timeout)); in ssl_reset_retransmit_timeout()
901 int mbedtls_ssl_encrypt_buf(mbedtls_ssl_context *ssl, in mbedtls_ssl_encrypt_buf() argument
923 ssl = NULL; /* make sure we don't use it except for debug */ in mbedtls_ssl_encrypt_buf()
924 ((void) ssl); in mbedtls_ssl_encrypt_buf()
1479 int mbedtls_ssl_decrypt_buf(mbedtls_ssl_context const *ssl, in mbedtls_ssl_decrypt_buf() argument
1506 ssl = NULL; /* make sure we don't use it except for debug */ in mbedtls_ssl_decrypt_buf()
1507 ((void) ssl); in mbedtls_ssl_decrypt_buf()
2145 int mbedtls_ssl_fetch_input(mbedtls_ssl_context *ssl, size_t nb_want) in mbedtls_ssl_fetch_input() argument
2150 size_t in_buf_len = ssl->in_buf_len; in mbedtls_ssl_fetch_input()
2157 if (ssl->f_recv == NULL && ssl->f_recv_timeout == NULL) { in mbedtls_ssl_fetch_input()
2162 if (nb_want > in_buf_len - (size_t) (ssl->in_hdr - ssl->in_buf)) { in mbedtls_ssl_fetch_input()
2168 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_fetch_input()
2181 if (ssl->next_record_offset != 0) { in mbedtls_ssl_fetch_input()
2182 if (ssl->in_left < ssl->next_record_offset) { in mbedtls_ssl_fetch_input()
2187 ssl->in_left -= ssl->next_record_offset; in mbedtls_ssl_fetch_input()
2189 if (ssl->in_left != 0) { in mbedtls_ssl_fetch_input()
2192 ssl->next_record_offset)); in mbedtls_ssl_fetch_input()
2193 memmove(ssl->in_hdr, in mbedtls_ssl_fetch_input()
2194 ssl->in_hdr + ssl->next_record_offset, in mbedtls_ssl_fetch_input()
2195 ssl->in_left); in mbedtls_ssl_fetch_input()
2198 ssl->next_record_offset = 0; in mbedtls_ssl_fetch_input()
2203 ssl->in_left, nb_want)); in mbedtls_ssl_fetch_input()
2208 if (nb_want <= ssl->in_left) { in mbedtls_ssl_fetch_input()
2218 if (ssl->in_left != 0) { in mbedtls_ssl_fetch_input()
2228 if (mbedtls_ssl_check_timer(ssl) != 0) { in mbedtls_ssl_fetch_input()
2232 len = in_buf_len - (size_t) (ssl->in_hdr - ssl->in_buf); in mbedtls_ssl_fetch_input()
2234 if (mbedtls_ssl_is_handshake_over(ssl) == 0) { in mbedtls_ssl_fetch_input()
2235 timeout = ssl->handshake->retransmit_timeout; in mbedtls_ssl_fetch_input()
2237 timeout = ssl->conf->read_timeout; in mbedtls_ssl_fetch_input()
2242 if (ssl->f_recv_timeout != NULL) { in mbedtls_ssl_fetch_input()
2243 ret = ssl->f_recv_timeout(ssl->p_bio, ssl->in_hdr, len, in mbedtls_ssl_fetch_input()
2246 ret = ssl->f_recv(ssl->p_bio, ssl->in_hdr, len); in mbedtls_ssl_fetch_input()
2258 mbedtls_ssl_set_timer(ssl, 0); in mbedtls_ssl_fetch_input()
2260 if (ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER) { in mbedtls_ssl_fetch_input()
2261 if (ssl_double_retransmit_timeout(ssl) != 0) { in mbedtls_ssl_fetch_input()
2266 if ((ret = mbedtls_ssl_resend(ssl)) != 0) { in mbedtls_ssl_fetch_input()
2274 else if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER && in mbedtls_ssl_fetch_input()
2275 ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING) { in mbedtls_ssl_fetch_input()
2276 if ((ret = mbedtls_ssl_resend_hello_request(ssl)) != 0) { in mbedtls_ssl_fetch_input()
2291 ssl->in_left = ret; in mbedtls_ssl_fetch_input()
2297 ssl->in_left, nb_want)); in mbedtls_ssl_fetch_input()
2299 while (ssl->in_left < nb_want) { in mbedtls_ssl_fetch_input()
2300 len = nb_want - ssl->in_left; in mbedtls_ssl_fetch_input()
2302 if (mbedtls_ssl_check_timer(ssl) != 0) { in mbedtls_ssl_fetch_input()
2305 if (ssl->f_recv_timeout != NULL) { in mbedtls_ssl_fetch_input()
2306 ret = ssl->f_recv_timeout(ssl->p_bio, in mbedtls_ssl_fetch_input()
2307 ssl->in_hdr + ssl->in_left, len, in mbedtls_ssl_fetch_input()
2308 ssl->conf->read_timeout); in mbedtls_ssl_fetch_input()
2310 ret = ssl->f_recv(ssl->p_bio, in mbedtls_ssl_fetch_input()
2311 ssl->in_hdr + ssl->in_left, len); in mbedtls_ssl_fetch_input()
2317 ssl->in_left, nb_want)); in mbedtls_ssl_fetch_input()
2336 ssl->in_left += ret; in mbedtls_ssl_fetch_input()
2348 int mbedtls_ssl_flush_output(mbedtls_ssl_context *ssl) in mbedtls_ssl_flush_output() argument
2355 if (ssl->f_send == NULL) { in mbedtls_ssl_flush_output()
2361 if (ssl->out_left == 0) { in mbedtls_ssl_flush_output()
2366 while (ssl->out_left > 0) { in mbedtls_ssl_flush_output()
2369 mbedtls_ssl_out_hdr_len(ssl) + ssl->out_msglen, ssl->out_left)); in mbedtls_ssl_flush_output()
2371 buf = ssl->out_hdr - ssl->out_left; in mbedtls_ssl_flush_output()
2372 ret = ssl->f_send(ssl->p_bio, buf, ssl->out_left); in mbedtls_ssl_flush_output()
2380 if ((size_t) ret > ssl->out_left) { in mbedtls_ssl_flush_output()
2384 ret, ssl->out_left)); in mbedtls_ssl_flush_output()
2388 ssl->out_left -= ret; in mbedtls_ssl_flush_output()
2392 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_flush_output()
2393 ssl->out_hdr = ssl->out_buf; in mbedtls_ssl_flush_output()
2397 ssl->out_hdr = ssl->out_buf + 8; in mbedtls_ssl_flush_output()
2399 mbedtls_ssl_update_out_pointers(ssl, ssl->transform_out); in mbedtls_ssl_flush_output()
2414 static int ssl_flight_append(mbedtls_ssl_context *ssl) in ssl_flight_append() argument
2419 ssl->out_msg, ssl->out_msglen); in ssl_flight_append()
2428 if ((msg->p = mbedtls_calloc(1, ssl->out_msglen)) == NULL) { in ssl_flight_append()
2430 ssl->out_msglen)); in ssl_flight_append()
2436 memcpy(msg->p, ssl->out_msg, ssl->out_msglen); in ssl_flight_append()
2437 msg->len = ssl->out_msglen; in ssl_flight_append()
2438 msg->type = ssl->out_msgtype; in ssl_flight_append()
2442 if (ssl->handshake->flight == NULL) { in ssl_flight_append()
2443 ssl->handshake->flight = msg; in ssl_flight_append()
2445 mbedtls_ssl_flight_item *cur = ssl->handshake->flight; in ssl_flight_append()
2478 static int ssl_swap_epochs(mbedtls_ssl_context *ssl) in ssl_swap_epochs() argument
2483 if (ssl->transform_out == ssl->handshake->alt_transform_out) { in ssl_swap_epochs()
2491 tmp_transform = ssl->transform_out; in ssl_swap_epochs()
2492 ssl->transform_out = ssl->handshake->alt_transform_out; in ssl_swap_epochs()
2493 ssl->handshake->alt_transform_out = tmp_transform; in ssl_swap_epochs()
2496 memcpy(tmp_out_ctr, ssl->cur_out_ctr, sizeof(tmp_out_ctr)); in ssl_swap_epochs()
2497 memcpy(ssl->cur_out_ctr, ssl->handshake->alt_out_ctr, in ssl_swap_epochs()
2498 sizeof(ssl->cur_out_ctr)); in ssl_swap_epochs()
2499 memcpy(ssl->handshake->alt_out_ctr, tmp_out_ctr, in ssl_swap_epochs()
2500 sizeof(ssl->handshake->alt_out_ctr)); in ssl_swap_epochs()
2503 mbedtls_ssl_update_out_pointers(ssl, ssl->transform_out); in ssl_swap_epochs()
2511 int mbedtls_ssl_resend(mbedtls_ssl_context *ssl) in mbedtls_ssl_resend() argument
2517 ret = mbedtls_ssl_flight_transmit(ssl); in mbedtls_ssl_resend()
2531 int mbedtls_ssl_flight_transmit(mbedtls_ssl_context *ssl) in mbedtls_ssl_flight_transmit() argument
2536 if (ssl->handshake->retransmit_state != MBEDTLS_SSL_RETRANS_SENDING) { in mbedtls_ssl_flight_transmit()
2539 ssl->handshake->cur_msg = ssl->handshake->flight; in mbedtls_ssl_flight_transmit()
2540 ssl->handshake->cur_msg_p = ssl->handshake->flight->p + 12; in mbedtls_ssl_flight_transmit()
2541 ret = ssl_swap_epochs(ssl); in mbedtls_ssl_flight_transmit()
2546 ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_SENDING; in mbedtls_ssl_flight_transmit()
2549 while (ssl->handshake->cur_msg != NULL) { in mbedtls_ssl_flight_transmit()
2551 const mbedtls_ssl_flight_item * const cur = ssl->handshake->cur_msg; in mbedtls_ssl_flight_transmit()
2557 int const force_flush = ssl->disable_datagram_packing == 1 ? in mbedtls_ssl_flight_transmit()
2563 if (is_finished && ssl->handshake->cur_msg_p == (cur->p + 12)) { in mbedtls_ssl_flight_transmit()
2565 ret = ssl_swap_epochs(ssl); in mbedtls_ssl_flight_transmit()
2571 ret = ssl_get_remaining_payload_in_datagram(ssl); in mbedtls_ssl_flight_transmit()
2580 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) { in mbedtls_ssl_flight_transmit()
2587 memcpy(ssl->out_msg, cur->p, cur->len); in mbedtls_ssl_flight_transmit()
2588 ssl->out_msglen = cur->len; in mbedtls_ssl_flight_transmit()
2589 ssl->out_msgtype = cur->type; in mbedtls_ssl_flight_transmit()
2592 ssl->handshake->cur_msg_p += cur->len; in mbedtls_ssl_flight_transmit()
2594 const unsigned char * const p = ssl->handshake->cur_msg_p; in mbedtls_ssl_flight_transmit()
2602 ret = ssl_swap_epochs(ssl); in mbedtls_ssl_flight_transmit()
2608 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) { in mbedtls_ssl_flight_transmit()
2628 memcpy(ssl->out_msg, cur->p, 6); in mbedtls_ssl_flight_transmit()
2630 ssl->out_msg[6] = MBEDTLS_BYTE_2(frag_off); in mbedtls_ssl_flight_transmit()
2631 ssl->out_msg[7] = MBEDTLS_BYTE_1(frag_off); in mbedtls_ssl_flight_transmit()
2632 ssl->out_msg[8] = MBEDTLS_BYTE_0(frag_off); in mbedtls_ssl_flight_transmit()
2634 ssl->out_msg[9] = MBEDTLS_BYTE_2(cur_hs_frag_len); in mbedtls_ssl_flight_transmit()
2635 ssl->out_msg[10] = MBEDTLS_BYTE_1(cur_hs_frag_len); in mbedtls_ssl_flight_transmit()
2636 ssl->out_msg[11] = MBEDTLS_BYTE_0(cur_hs_frag_len); in mbedtls_ssl_flight_transmit()
2638 MBEDTLS_SSL_DEBUG_BUF(3, "handshake header", ssl->out_msg, 12); in mbedtls_ssl_flight_transmit()
2641 memcpy(ssl->out_msg + 12, p, cur_hs_frag_len); in mbedtls_ssl_flight_transmit()
2642 ssl->out_msglen = cur_hs_frag_len + 12; in mbedtls_ssl_flight_transmit()
2643 ssl->out_msgtype = cur->type; in mbedtls_ssl_flight_transmit()
2646 ssl->handshake->cur_msg_p += cur_hs_frag_len; in mbedtls_ssl_flight_transmit()
2650 if (ssl->handshake->cur_msg_p >= cur->p + cur->len) { in mbedtls_ssl_flight_transmit()
2652 ssl->handshake->cur_msg = cur->next; in mbedtls_ssl_flight_transmit()
2653 ssl->handshake->cur_msg_p = cur->next->p + 12; in mbedtls_ssl_flight_transmit()
2655 ssl->handshake->cur_msg = NULL; in mbedtls_ssl_flight_transmit()
2656 ssl->handshake->cur_msg_p = NULL; in mbedtls_ssl_flight_transmit()
2661 if ((ret = mbedtls_ssl_write_record(ssl, force_flush)) != 0) { in mbedtls_ssl_flight_transmit()
2667 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) { in mbedtls_ssl_flight_transmit()
2672 if (mbedtls_ssl_is_handshake_over(ssl) == 1) { in mbedtls_ssl_flight_transmit()
2673 ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_FINISHED; in mbedtls_ssl_flight_transmit()
2675 ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_WAITING; in mbedtls_ssl_flight_transmit()
2676 mbedtls_ssl_set_timer(ssl, ssl->handshake->retransmit_timeout); in mbedtls_ssl_flight_transmit()
2687 void mbedtls_ssl_recv_flight_completed(mbedtls_ssl_context *ssl) in mbedtls_ssl_recv_flight_completed() argument
2690 mbedtls_ssl_flight_free(ssl->handshake->flight); in mbedtls_ssl_recv_flight_completed()
2691 ssl->handshake->flight = NULL; in mbedtls_ssl_recv_flight_completed()
2692 ssl->handshake->cur_msg = NULL; in mbedtls_ssl_recv_flight_completed()
2695 ssl->handshake->in_flight_start_seq = ssl->handshake->in_msg_seq; in mbedtls_ssl_recv_flight_completed()
2698 ssl->handshake->buffering.seen_ccs = 0; in mbedtls_ssl_recv_flight_completed()
2701 mbedtls_ssl_buffering_free(ssl); in mbedtls_ssl_recv_flight_completed()
2704 mbedtls_ssl_set_timer(ssl, 0); in mbedtls_ssl_recv_flight_completed()
2706 if (ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE && in mbedtls_ssl_recv_flight_completed()
2707 ssl->in_msg[0] == MBEDTLS_SSL_HS_FINISHED) { in mbedtls_ssl_recv_flight_completed()
2708 ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_FINISHED; in mbedtls_ssl_recv_flight_completed()
2710 ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_PREPARING; in mbedtls_ssl_recv_flight_completed()
2717 void mbedtls_ssl_send_flight_completed(mbedtls_ssl_context *ssl) in mbedtls_ssl_send_flight_completed() argument
2719 ssl_reset_retransmit_timeout(ssl); in mbedtls_ssl_send_flight_completed()
2720 mbedtls_ssl_set_timer(ssl, ssl->handshake->retransmit_timeout); in mbedtls_ssl_send_flight_completed()
2722 if (ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE && in mbedtls_ssl_send_flight_completed()
2723 ssl->in_msg[0] == MBEDTLS_SSL_HS_FINISHED) { in mbedtls_ssl_send_flight_completed()
2724 ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_FINISHED; in mbedtls_ssl_send_flight_completed()
2726 ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_WAITING; in mbedtls_ssl_send_flight_completed()
2734 int mbedtls_ssl_start_handshake_msg(mbedtls_ssl_context *ssl, unsigned char hs_type, in mbedtls_ssl_start_handshake_msg() argument
2744 *buf = ssl->out_msg + 4; in mbedtls_ssl_start_handshake_msg()
2747 ssl->out_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE; in mbedtls_ssl_start_handshake_msg()
2748 ssl->out_msg[0] = hs_type; in mbedtls_ssl_start_handshake_msg()
2775 int mbedtls_ssl_write_handshake_msg_ext(mbedtls_ssl_context *ssl, in mbedtls_ssl_write_handshake_msg_ext() argument
2780 const size_t hs_len = ssl->out_msglen - 4; in mbedtls_ssl_write_handshake_msg_ext()
2781 const unsigned char hs_type = ssl->out_msg[0]; in mbedtls_ssl_write_handshake_msg_ext()
2788 if (ssl->out_msgtype != MBEDTLS_SSL_MSG_HANDSHAKE && in mbedtls_ssl_write_handshake_msg_ext()
2789 ssl->out_msgtype != MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC) { in mbedtls_ssl_write_handshake_msg_ext()
2796 if (!(ssl->out_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE && in mbedtls_ssl_write_handshake_msg_ext()
2798 ssl->handshake == NULL) { in mbedtls_ssl_write_handshake_msg_ext()
2804 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM && in mbedtls_ssl_write_handshake_msg_ext()
2805 ssl->handshake != NULL && in mbedtls_ssl_write_handshake_msg_ext()
2806 ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING) { in mbedtls_ssl_write_handshake_msg_ext()
2820 if (ssl->out_msglen > MBEDTLS_SSL_OUT_CONTENT_LEN) { in mbedtls_ssl_write_handshake_msg_ext()
2824 ssl->out_msglen, in mbedtls_ssl_write_handshake_msg_ext()
2832 if (ssl->out_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE) { in mbedtls_ssl_write_handshake_msg_ext()
2833 ssl->out_msg[1] = MBEDTLS_BYTE_2(hs_len); in mbedtls_ssl_write_handshake_msg_ext()
2834 ssl->out_msg[2] = MBEDTLS_BYTE_1(hs_len); in mbedtls_ssl_write_handshake_msg_ext()
2835 ssl->out_msg[3] = MBEDTLS_BYTE_0(hs_len); in mbedtls_ssl_write_handshake_msg_ext()
2845 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_write_handshake_msg_ext()
2847 if (MBEDTLS_SSL_OUT_CONTENT_LEN - ssl->out_msglen < 8) { in mbedtls_ssl_write_handshake_msg_ext()
2856 memmove(ssl->out_msg + 12, ssl->out_msg + 4, hs_len); in mbedtls_ssl_write_handshake_msg_ext()
2857 ssl->out_msglen += 8; in mbedtls_ssl_write_handshake_msg_ext()
2861 MBEDTLS_PUT_UINT16_BE(ssl->handshake->out_msg_seq, ssl->out_msg, 4); in mbedtls_ssl_write_handshake_msg_ext()
2862 ++(ssl->handshake->out_msg_seq); in mbedtls_ssl_write_handshake_msg_ext()
2864 ssl->out_msg[4] = 0; in mbedtls_ssl_write_handshake_msg_ext()
2865 ssl->out_msg[5] = 0; in mbedtls_ssl_write_handshake_msg_ext()
2870 memset(ssl->out_msg + 6, 0x00, 3); in mbedtls_ssl_write_handshake_msg_ext()
2871 memcpy(ssl->out_msg + 9, ssl->out_msg + 1, 3); in mbedtls_ssl_write_handshake_msg_ext()
2877 ret = ssl->handshake->update_checksum(ssl, ssl->out_msg, in mbedtls_ssl_write_handshake_msg_ext()
2878 ssl->out_msglen); in mbedtls_ssl_write_handshake_msg_ext()
2888 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM && in mbedtls_ssl_write_handshake_msg_ext()
2889 !(ssl->out_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE && in mbedtls_ssl_write_handshake_msg_ext()
2891 if ((ret = ssl_flight_append(ssl)) != 0) { in mbedtls_ssl_write_handshake_msg_ext()
2898 if ((ret = mbedtls_ssl_write_record(ssl, force_flush)) != 0) { in mbedtls_ssl_write_handshake_msg_ext()
2909 int mbedtls_ssl_finish_handshake_msg(mbedtls_ssl_context *ssl, in mbedtls_ssl_finish_handshake_msg() argument
2918 ssl->out_msglen = msg_with_header_len; in mbedtls_ssl_finish_handshake_msg()
2919 MBEDTLS_SSL_PROC_CHK(mbedtls_ssl_write_handshake_msg_ext(ssl, 0, 0)); in mbedtls_ssl_finish_handshake_msg()
2937 int mbedtls_ssl_write_record(mbedtls_ssl_context *ssl, int force_flush) in mbedtls_ssl_write_record() argument
2940 size_t len = ssl->out_msglen; in mbedtls_ssl_write_record()
2949 size_t out_buf_len = ssl->out_buf_len; in mbedtls_ssl_write_record()
2955 mbedtls_ssl_protocol_version tls_ver = ssl->tls_version; in mbedtls_ssl_write_record()
2963 mbedtls_ssl_write_version(ssl->out_hdr + 1, ssl->conf->transport, in mbedtls_ssl_write_record()
2966 memcpy(ssl->out_ctr, ssl->cur_out_ctr, MBEDTLS_SSL_SEQUENCE_NUMBER_LEN); in mbedtls_ssl_write_record()
2967 MBEDTLS_PUT_UINT16_BE(len, ssl->out_len, 0); in mbedtls_ssl_write_record()
2969 if (ssl->transform_out != NULL) { in mbedtls_ssl_write_record()
2972 rec.buf = ssl->out_iv; in mbedtls_ssl_write_record()
2973 rec.buf_len = out_buf_len - (size_t) (ssl->out_iv - ssl->out_buf); in mbedtls_ssl_write_record()
2974 rec.data_len = ssl->out_msglen; in mbedtls_ssl_write_record()
2975 rec.data_offset = (size_t) (ssl->out_msg - rec.buf); in mbedtls_ssl_write_record()
2977 memcpy(&rec.ctr[0], ssl->out_ctr, sizeof(rec.ctr)); in mbedtls_ssl_write_record()
2978 mbedtls_ssl_write_version(rec.ver, ssl->conf->transport, tls_ver); in mbedtls_ssl_write_record()
2979 rec.type = ssl->out_msgtype; in mbedtls_ssl_write_record()
2986 if ((ret = mbedtls_ssl_encrypt_buf(ssl, ssl->transform_out, &rec, in mbedtls_ssl_write_record()
2987 ssl->conf->f_rng, ssl->conf->p_rng)) != 0) { in mbedtls_ssl_write_record()
2998 ssl->out_msgtype = rec.type; in mbedtls_ssl_write_record()
3000 memcpy(ssl->out_cid, rec.cid, rec.cid_len); in mbedtls_ssl_write_record()
3002 ssl->out_msglen = len = rec.data_len; in mbedtls_ssl_write_record()
3003 MBEDTLS_PUT_UINT16_BE(rec.data_len, ssl->out_len, 0); in mbedtls_ssl_write_record()
3006 protected_record_size = len + mbedtls_ssl_out_hdr_len(ssl); in mbedtls_ssl_write_record()
3011 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_write_record()
3012 ret = ssl_get_remaining_space_in_datagram(ssl); in mbedtls_ssl_write_record()
3025 ssl->out_hdr[0] = (unsigned char) ssl->out_msgtype; in mbedtls_ssl_write_record()
3029 ssl->out_hdr[0], ssl->out_hdr[1], in mbedtls_ssl_write_record()
3030 ssl->out_hdr[2], len)); in mbedtls_ssl_write_record()
3033 ssl->out_hdr, protected_record_size); in mbedtls_ssl_write_record()
3035 ssl->out_left += protected_record_size; in mbedtls_ssl_write_record()
3036 ssl->out_hdr += protected_record_size; in mbedtls_ssl_write_record()
3037 mbedtls_ssl_update_out_pointers(ssl, ssl->transform_out); in mbedtls_ssl_write_record()
3039 for (i = 8; i > mbedtls_ssl_ep_len(ssl); i--) { in mbedtls_ssl_write_record()
3040 if (++ssl->cur_out_ctr[i - 1] != 0) { in mbedtls_ssl_write_record()
3046 if (i == mbedtls_ssl_ep_len(ssl)) { in mbedtls_ssl_write_record()
3053 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM && in mbedtls_ssl_write_record()
3056 ret = ssl_get_remaining_payload_in_datagram(ssl); in mbedtls_ssl_write_record()
3075 (ret = mbedtls_ssl_flush_output(ssl)) != 0) { in mbedtls_ssl_write_record()
3088 static int ssl_hs_is_proper_fragment(mbedtls_ssl_context *ssl) in ssl_hs_is_proper_fragment() argument
3090 if (ssl->in_msglen < ssl->in_hslen || in ssl_hs_is_proper_fragment()
3091 memcmp(ssl->in_msg + 6, "\0\0\0", 3) != 0 || in ssl_hs_is_proper_fragment()
3092 memcmp(ssl->in_msg + 9, ssl->in_msg + 1, 3) != 0) { in ssl_hs_is_proper_fragment()
3098 static uint32_t ssl_get_hs_frag_len(mbedtls_ssl_context const *ssl) in ssl_get_hs_frag_len() argument
3100 return MBEDTLS_GET_UINT24_BE(ssl->in_msg, 9); in ssl_get_hs_frag_len()
3103 static uint32_t ssl_get_hs_frag_off(mbedtls_ssl_context const *ssl) in ssl_get_hs_frag_off() argument
3105 return MBEDTLS_GET_UINT24_BE(ssl->in_msg, 6); in ssl_get_hs_frag_off()
3109 static int ssl_check_hs_header(mbedtls_ssl_context const *ssl) in ssl_check_hs_header() argument
3113 msg_len = ssl_get_hs_total_len(ssl); in ssl_check_hs_header()
3114 frag_off = ssl_get_hs_frag_off(ssl); in ssl_check_hs_header()
3115 frag_len = ssl_get_hs_frag_len(ssl); in ssl_check_hs_header()
3125 if (frag_len + 12 > ssl->in_msglen) { in ssl_check_hs_header()
3216 static uint32_t ssl_get_hs_total_len(mbedtls_ssl_context const *ssl) in ssl_get_hs_total_len() argument
3218 return MBEDTLS_GET_UINT24_BE(ssl->in_msg, 1); in ssl_get_hs_total_len()
3221 int mbedtls_ssl_prepare_handshake_record(mbedtls_ssl_context *ssl) in mbedtls_ssl_prepare_handshake_record() argument
3223 if (ssl->in_msglen < mbedtls_ssl_hs_hdr_len(ssl)) { in mbedtls_ssl_prepare_handshake_record()
3225 ssl->in_msglen)); in mbedtls_ssl_prepare_handshake_record()
3229 ssl->in_hslen = mbedtls_ssl_hs_hdr_len(ssl) + ssl_get_hs_total_len(ssl); in mbedtls_ssl_prepare_handshake_record()
3234 ssl->in_msglen, ssl->in_msg[0], ssl->in_hslen)); in mbedtls_ssl_prepare_handshake_record()
3237 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_prepare_handshake_record()
3239 unsigned int recv_msg_seq = MBEDTLS_GET_UINT16_BE(ssl->in_msg, 4); in mbedtls_ssl_prepare_handshake_record()
3241 if (ssl_check_hs_header(ssl) != 0) { in mbedtls_ssl_prepare_handshake_record()
3246 if (ssl->handshake != NULL && in mbedtls_ssl_prepare_handshake_record()
3247 ((mbedtls_ssl_is_handshake_over(ssl) == 0 && in mbedtls_ssl_prepare_handshake_record()
3248 recv_msg_seq != ssl->handshake->in_msg_seq) || in mbedtls_ssl_prepare_handshake_record()
3249 (mbedtls_ssl_is_handshake_over(ssl) == 1 && in mbedtls_ssl_prepare_handshake_record()
3250 ssl->in_msg[0] != MBEDTLS_SSL_HS_CLIENT_HELLO))) { in mbedtls_ssl_prepare_handshake_record()
3251 if (recv_msg_seq > ssl->handshake->in_msg_seq) { in mbedtls_ssl_prepare_handshake_record()
3256 ssl->handshake->in_msg_seq)); in mbedtls_ssl_prepare_handshake_record()
3263 if (recv_msg_seq == ssl->handshake->in_flight_start_seq - 1 && in mbedtls_ssl_prepare_handshake_record()
3264 ssl->in_msg[0] != MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST) { in mbedtls_ssl_prepare_handshake_record()
3268 ssl->handshake->in_flight_start_seq)); in mbedtls_ssl_prepare_handshake_record()
3270 if ((ret = mbedtls_ssl_resend(ssl)) != 0) { in mbedtls_ssl_prepare_handshake_record()
3278 ssl->handshake->in_msg_seq)); in mbedtls_ssl_prepare_handshake_record()
3289 if (ssl_hs_is_proper_fragment(ssl) == 1) { in mbedtls_ssl_prepare_handshake_record()
3296 if (ssl->in_msglen < ssl->in_hslen) { in mbedtls_ssl_prepare_handshake_record()
3304 int mbedtls_ssl_update_handshake_status(mbedtls_ssl_context *ssl) in mbedtls_ssl_update_handshake_status() argument
3307 mbedtls_ssl_handshake_params * const hs = ssl->handshake; in mbedtls_ssl_update_handshake_status()
3309 if (mbedtls_ssl_is_handshake_over(ssl) == 0 && hs != NULL) { in mbedtls_ssl_update_handshake_status()
3310 ret = ssl->handshake->update_checksum(ssl, ssl->in_msg, ssl->in_hslen); in mbedtls_ssl_update_handshake_status()
3319 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM && in mbedtls_ssl_update_handshake_status()
3320 ssl->handshake != NULL) { in mbedtls_ssl_update_handshake_status()
3332 ssl_buffering_free_slot(ssl, 0); in mbedtls_ssl_update_handshake_status()
3359 void mbedtls_ssl_dtls_replay_reset(mbedtls_ssl_context *ssl) in mbedtls_ssl_dtls_replay_reset() argument
3361 ssl->in_window_top = 0; in mbedtls_ssl_dtls_replay_reset()
3362 ssl->in_window = 0; in mbedtls_ssl_dtls_replay_reset()
3376 static int mbedtls_ssl_dtls_record_replay_check(mbedtls_ssl_context *ssl, uint8_t *record_in_ctr) in mbedtls_ssl_dtls_record_replay_check() argument
3382 original_in_ctr = ssl->in_ctr; in mbedtls_ssl_dtls_record_replay_check()
3385 ssl->in_ctr = record_in_ctr; in mbedtls_ssl_dtls_record_replay_check()
3387 ret = mbedtls_ssl_dtls_replay_check((mbedtls_ssl_context const *) ssl); in mbedtls_ssl_dtls_record_replay_check()
3390 ssl->in_ctr = original_in_ctr; in mbedtls_ssl_dtls_record_replay_check()
3398 int mbedtls_ssl_dtls_replay_check(mbedtls_ssl_context const *ssl) in mbedtls_ssl_dtls_replay_check() argument
3400 uint64_t rec_seqnum = ssl_load_six_bytes(ssl->in_ctr + 2); in mbedtls_ssl_dtls_replay_check()
3403 if (ssl->conf->anti_replay == MBEDTLS_SSL_ANTI_REPLAY_DISABLED) { in mbedtls_ssl_dtls_replay_check()
3407 if (rec_seqnum > ssl->in_window_top) { in mbedtls_ssl_dtls_replay_check()
3411 bit = ssl->in_window_top - rec_seqnum; in mbedtls_ssl_dtls_replay_check()
3417 if ((ssl->in_window & ((uint64_t) 1 << bit)) != 0) { in mbedtls_ssl_dtls_replay_check()
3427 void mbedtls_ssl_dtls_replay_update(mbedtls_ssl_context *ssl) in mbedtls_ssl_dtls_replay_update() argument
3429 uint64_t rec_seqnum = ssl_load_six_bytes(ssl->in_ctr + 2); in mbedtls_ssl_dtls_replay_update()
3431 if (ssl->conf->anti_replay == MBEDTLS_SSL_ANTI_REPLAY_DISABLED) { in mbedtls_ssl_dtls_replay_update()
3435 if (rec_seqnum > ssl->in_window_top) { in mbedtls_ssl_dtls_replay_update()
3437 uint64_t shift = rec_seqnum - ssl->in_window_top; in mbedtls_ssl_dtls_replay_update()
3440 ssl->in_window = 1; in mbedtls_ssl_dtls_replay_update()
3442 ssl->in_window <<= shift; in mbedtls_ssl_dtls_replay_update()
3443 ssl->in_window |= 1; in mbedtls_ssl_dtls_replay_update()
3446 ssl->in_window_top = rec_seqnum; in mbedtls_ssl_dtls_replay_update()
3449 uint64_t bit = ssl->in_window_top - rec_seqnum; in mbedtls_ssl_dtls_replay_update()
3452 ssl->in_window |= (uint64_t) 1 << bit; in mbedtls_ssl_dtls_replay_update()
3473 mbedtls_ssl_context *ssl, in mbedtls_ssl_check_dtls_clihlo_cookie() argument
3547 if (ssl->conf->f_cookie_check(ssl->conf->p_cookie, in mbedtls_ssl_check_dtls_clihlo_cookie()
3586 if (ssl->conf->f_cookie_write(ssl->conf->p_cookie, in mbedtls_ssl_check_dtls_clihlo_cookie()
3627 static int ssl_handle_possible_reconnect(mbedtls_ssl_context *ssl) in ssl_handle_possible_reconnect() argument
3632 if (ssl->conf->f_cookie_write == NULL || in ssl_handle_possible_reconnect()
3633 ssl->conf->f_cookie_check == NULL) { in ssl_handle_possible_reconnect()
3642 ssl, in ssl_handle_possible_reconnect()
3643 ssl->cli_id, ssl->cli_id_len, in ssl_handle_possible_reconnect()
3644 ssl->in_buf, ssl->in_left, in ssl_handle_possible_reconnect()
3645 ssl->out_buf, MBEDTLS_SSL_OUT_CONTENT_LEN, &len); in ssl_handle_possible_reconnect()
3653 ssl->out_buf, len); in ssl_handle_possible_reconnect()
3657 send_ret = ssl->f_send(ssl->p_bio, ssl->out_buf, len); in ssl_handle_possible_reconnect()
3666 if ((ret = mbedtls_ssl_session_reset_int(ssl, 1)) != 0) { in ssl_handle_possible_reconnect()
3711 static int ssl_parse_record_header(mbedtls_ssl_context const *ssl, in ssl_parse_record_header() argument
3746 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_parse_record_header()
3773 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM && in ssl_parse_record_header()
3774 ssl->conf->cid_len != 0 && in ssl_parse_record_header()
3791 rec_hdr_cid_len = ssl->conf->cid_len; in ssl_parse_record_header()
3824 ssl->conf->transport); in ssl_parse_record_header()
3826 if (tls_version > ssl->conf->max_tls_version) { in ssl_parse_record_header()
3829 (unsigned) ssl->conf->max_tls_version)); in ssl_parse_record_header()
3838 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_parse_record_header()
3846 memcpy(&rec->ctr[0], ssl->in_ctr, rec_hdr_ctr_len); in ssl_parse_record_header()
3881 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_parse_record_header()
3898 if (rec_epoch != ssl->in_epoch) { in ssl_parse_record_header()
3901 ssl->in_epoch, (unsigned long) rec_epoch)); in ssl_parse_record_header()
3905 if (rec_epoch == (unsigned) ssl->in_epoch + 1) { in ssl_parse_record_header()
3915 else if (mbedtls_ssl_dtls_record_replay_check((mbedtls_ssl_context *) ssl, in ssl_parse_record_header()
3930 static int ssl_check_client_reconnect(mbedtls_ssl_context *ssl) in ssl_check_client_reconnect() argument
3932 unsigned int rec_epoch = MBEDTLS_GET_UINT16_BE(ssl->in_ctr, 0); in ssl_check_client_reconnect()
3941 ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER && in ssl_check_client_reconnect()
3942 mbedtls_ssl_is_handshake_over(ssl) == 1 && in ssl_check_client_reconnect()
3943 ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE && in ssl_check_client_reconnect()
3944 ssl->in_left > 13 && in ssl_check_client_reconnect()
3945 ssl->in_buf[13] == MBEDTLS_SSL_HS_CLIENT_HELLO) { in ssl_check_client_reconnect()
3948 return ssl_handle_possible_reconnect(ssl); in ssl_check_client_reconnect()
3959 static int ssl_prepare_record_content(mbedtls_ssl_context *ssl, in ssl_prepare_record_content() argument
3973 if (ssl->transform_in != NULL && in ssl_prepare_record_content()
3974 ssl->transform_in->tls_version == MBEDTLS_SSL_VERSION_TLS1_3) { in ssl_prepare_record_content()
3981 if (!done && ssl->transform_in != NULL) { in ssl_prepare_record_content()
3984 if ((ret = mbedtls_ssl_decrypt_buf(ssl, ssl->transform_in, in ssl_prepare_record_content()
4004 (ssl->discard_early_data_record == in ssl_prepare_record_content()
4009 ret = mbedtls_ssl_tls13_check_early_data_len(ssl, rec->data_len); in ssl_prepare_record_content()
4019 ssl->conf->ignore_unexpected_cid in ssl_prepare_record_content()
4041 if (ssl->discard_early_data_record == in ssl_prepare_record_content()
4043 ssl->discard_early_data_record = MBEDTLS_SSL_EARLY_DATA_NO_DISCARD; in ssl_prepare_record_content()
4071 if (ssl->tls_version == MBEDTLS_SSL_VERSION_TLS1_2 in ssl_prepare_record_content()
4074 MBEDTLS_SSL_DEBUG_MSG(1, ("invalid zero-length message type: %d", ssl->in_msgtype)); in ssl_prepare_record_content()
4079 ssl->nb_zero++; in ssl_prepare_record_content()
4085 if (ssl->nb_zero > 3) { in ssl_prepare_record_content()
4094 ssl->nb_zero = 0; in ssl_prepare_record_content()
4098 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_prepare_record_content()
4105 i > mbedtls_ssl_ep_len(ssl); i--) { in ssl_prepare_record_content()
4106 if (++ssl->in_ctr[i - 1] != 0) { in ssl_prepare_record_content()
4112 if (i == mbedtls_ssl_ep_len(ssl)) { in ssl_prepare_record_content()
4134 if (ssl->discard_early_data_record == MBEDTLS_SSL_EARLY_DATA_DISCARD) { in ssl_prepare_record_content()
4137 ret = mbedtls_ssl_tls13_check_early_data_len(ssl, rec->data_len); in ssl_prepare_record_content()
4147 ssl->discard_early_data_record = MBEDTLS_SSL_EARLY_DATA_NO_DISCARD; in ssl_prepare_record_content()
4153 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_prepare_record_content()
4154 mbedtls_ssl_dtls_replay_update(ssl); in ssl_prepare_record_content()
4178 static int ssl_consume_current_message(mbedtls_ssl_context *ssl);
4180 static int ssl_get_next_record(mbedtls_ssl_context *ssl);
4182 static int ssl_record_is_in_progress(mbedtls_ssl_context *ssl);
4184 int mbedtls_ssl_read_record(mbedtls_ssl_context *ssl, in mbedtls_ssl_read_record() argument
4191 if (ssl->keep_current_message == 0) { in mbedtls_ssl_read_record()
4194 ret = ssl_consume_current_message(ssl); in mbedtls_ssl_read_record()
4199 if (ssl_record_is_in_progress(ssl) == 0) { in mbedtls_ssl_read_record()
4205 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM && in mbedtls_ssl_read_record()
4206 ssl_next_record_is_in_datagram(ssl) == 0) { in mbedtls_ssl_read_record()
4207 if (ssl_load_buffered_message(ssl) == 0) { in mbedtls_ssl_read_record()
4214 ret = ssl_get_next_record(ssl); in mbedtls_ssl_read_record()
4226 ret = mbedtls_ssl_handle_message_type(ssl); in mbedtls_ssl_read_record()
4231 ret = ssl_buffer_message(ssl); in mbedtls_ssl_read_record()
4248 if (ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE && in mbedtls_ssl_read_record()
4250 ret = mbedtls_ssl_update_handshake_status(ssl); in mbedtls_ssl_read_record()
4258 ssl->keep_current_message = 0; in mbedtls_ssl_read_record()
4268 static int ssl_next_record_is_in_datagram(mbedtls_ssl_context *ssl) in ssl_next_record_is_in_datagram() argument
4270 if (ssl->in_left > ssl->next_record_offset) { in ssl_next_record_is_in_datagram()
4278 static int ssl_load_buffered_message(mbedtls_ssl_context *ssl) in ssl_load_buffered_message() argument
4280 mbedtls_ssl_handshake_params * const hs = ssl->handshake; in ssl_load_buffered_message()
4290 if (ssl->state == MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC || in ssl_load_buffered_message()
4291 ssl->state == MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC) { in ssl_load_buffered_message()
4301 ssl->in_msgtype = MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC; in ssl_load_buffered_message()
4302 ssl->in_msglen = 1; in ssl_load_buffered_message()
4303 ssl->in_msg[0] = 1; in ssl_load_buffered_message()
4306 ssl->in_left = 0; in ssl_load_buffered_message()
4307 ssl->next_record_offset = 0; in ssl_load_buffered_message()
4346 ssl->in_msgtype = MBEDTLS_SSL_MSG_HANDSHAKE; in ssl_load_buffered_message()
4347 ssl->in_hslen = msg_len + 12; in ssl_load_buffered_message()
4348 ssl->in_msglen = msg_len + 12; in ssl_load_buffered_message()
4349 memcpy(ssl->in_msg, hs_buf->data, ssl->in_hslen); in ssl_load_buffered_message()
4367 static int ssl_buffer_make_space(mbedtls_ssl_context *ssl, in ssl_buffer_make_space() argument
4371 mbedtls_ssl_handshake_params * const hs = ssl->handshake; in ssl_buffer_make_space()
4376 ssl_free_buffered_record(ssl); in ssl_buffer_make_space()
4395 ssl_buffering_free_slot(ssl, (uint8_t) offset); in ssl_buffer_make_space()
4409 static int ssl_buffer_message(mbedtls_ssl_context *ssl) in ssl_buffer_message() argument
4412 mbedtls_ssl_handshake_params * const hs = ssl->handshake; in ssl_buffer_message()
4420 switch (ssl->in_msgtype) { in ssl_buffer_message()
4430 unsigned recv_msg_seq = MBEDTLS_GET_UINT16_BE(ssl->in_msg, 4); in ssl_buffer_message()
4432 size_t msg_len = ssl->in_hslen - 12; in ssl_buffer_message()
4436 if (recv_msg_seq < ssl->handshake->in_msg_seq) { in ssl_buffer_message()
4441 recv_msg_seq_offset = recv_msg_seq - ssl->handshake->in_msg_seq; in ssl_buffer_message()
4447 recv_msg_seq, ssl->handshake->in_msg_seq, in ssl_buffer_message()
4448 ssl->handshake->in_msg_seq + MBEDTLS_SSL_MAX_BUFFERED_HS - in ssl_buffer_message()
4464 (ssl_hs_is_proper_fragment(ssl) == 1); in ssl_buffer_message()
4513 if (ssl_buffer_make_space(ssl, reassembly_buf_sz) != 0) { in ssl_buffer_message()
4546 memcpy(hs_buf->data, ssl->in_msg, 6); in ssl_buffer_message()
4555 if (memcmp(hs_buf->data, ssl->in_msg, 4) != 0) { in ssl_buffer_message()
4572 frag_off = ssl_get_hs_frag_off(ssl); in ssl_buffer_message()
4573 frag_len = ssl_get_hs_frag_len(ssl); in ssl_buffer_message()
4578 memcpy(msg + frag_off, ssl->in_msg + 12, frag_len); in ssl_buffer_message()
4609 static int ssl_consume_current_message(mbedtls_ssl_context *ssl) in ssl_consume_current_message() argument
4634 if (ssl->in_hslen != 0) { in ssl_consume_current_message()
4638 if (ssl->in_offt != NULL) { in ssl_consume_current_message()
4664 if (ssl->in_hslen < ssl->in_msglen) { in ssl_consume_current_message()
4665 ssl->in_msglen -= ssl->in_hslen; in ssl_consume_current_message()
4666 memmove(ssl->in_msg, ssl->in_msg + ssl->in_hslen, in ssl_consume_current_message()
4667 ssl->in_msglen); in ssl_consume_current_message()
4670 ssl->in_msg, ssl->in_msglen); in ssl_consume_current_message()
4672 ssl->in_msglen = 0; in ssl_consume_current_message()
4675 ssl->in_hslen = 0; in ssl_consume_current_message()
4678 else if (ssl->in_offt != NULL) { in ssl_consume_current_message()
4683 ssl->in_msglen = 0; in ssl_consume_current_message()
4690 static int ssl_record_is_in_progress(mbedtls_ssl_context *ssl) in ssl_record_is_in_progress() argument
4692 if (ssl->in_msglen > 0) { in ssl_record_is_in_progress()
4701 static void ssl_free_buffered_record(mbedtls_ssl_context *ssl) in ssl_free_buffered_record() argument
4703 mbedtls_ssl_handshake_params * const hs = ssl->handshake; in ssl_free_buffered_record()
4718 static int ssl_load_buffered_record(mbedtls_ssl_context *ssl) in ssl_load_buffered_record() argument
4720 mbedtls_ssl_handshake_params * const hs = ssl->handshake; in ssl_load_buffered_record()
4725 size_t in_buf_len = ssl->in_buf_len; in ssl_load_buffered_record()
4729 if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_load_buffered_record()
4747 if (ssl_next_record_is_in_datagram(ssl) == 1) { in ssl_load_buffered_record()
4753 if (rec_epoch != ssl->in_epoch) { in ssl_load_buffered_record()
4761 if (rec_len > in_buf_len - (size_t) (ssl->in_hdr - ssl->in_buf)) { in ssl_load_buffered_record()
4766 memcpy(ssl->in_hdr, rec, rec_len); in ssl_load_buffered_record()
4767 ssl->in_left = rec_len; in ssl_load_buffered_record()
4768 ssl->next_record_offset = 0; in ssl_load_buffered_record()
4770 ssl_free_buffered_record(ssl); in ssl_load_buffered_record()
4778 static int ssl_buffer_future_record(mbedtls_ssl_context *ssl, in ssl_buffer_future_record() argument
4781 mbedtls_ssl_handshake_params * const hs = ssl->handshake; in ssl_buffer_future_record()
4813 ssl->in_epoch + 1U)); in ssl_buffer_future_record()
4818 hs->buffering.future_record.epoch = ssl->in_epoch + 1; in ssl_buffer_future_record()
4838 static int ssl_get_next_record(mbedtls_ssl_context *ssl) in ssl_get_next_record() argument
4850 ret = ssl_load_buffered_record(ssl); in ssl_get_next_record()
4859 ret = mbedtls_ssl_fetch_input(ssl, mbedtls_ssl_in_hdr_len(ssl)); in ssl_get_next_record()
4865 ret = ssl_parse_record_header(ssl, ssl->in_hdr, ssl->in_left, &rec); in ssl_get_next_record()
4868 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_get_next_record()
4870 ret = ssl_buffer_future_record(ssl, &rec); in ssl_get_next_record()
4884 mbedtls_ssl_update_in_pointers(ssl); in ssl_get_next_record()
4887 ssl->in_msgtype = rec.type; in ssl_get_next_record()
4889 ssl->in_len = ssl->in_cid + rec.cid_len; in ssl_get_next_record()
4891 ssl->in_iv = ssl->in_msg = ssl->in_len + 2; in ssl_get_next_record()
4892 ssl->in_msglen = rec.data_len; in ssl_get_next_record()
4894 ret = ssl_check_client_reconnect(ssl); in ssl_get_next_record()
4902 ssl->next_record_offset = rec.buf_len; in ssl_get_next_record()
4908 ssl->next_record_offset = 0; in ssl_get_next_record()
4909 ssl->in_left = 0; in ssl_get_next_record()
4925 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_get_next_record()
4927 ssl->next_record_offset = rec.buf_len; in ssl_get_next_record()
4928 if (ssl->next_record_offset < ssl->in_left) { in ssl_get_next_record()
4937 ret = mbedtls_ssl_fetch_input(ssl, rec.buf_len); in ssl_get_next_record()
4943 ssl->in_left = 0; in ssl_get_next_record()
4950 if ((ret = ssl_prepare_record_content(ssl, &rec)) != 0) { in ssl_get_next_record()
4952 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_get_next_record()
4958 if (ssl->state == MBEDTLS_SSL_CLIENT_FINISHED || in ssl_get_next_record()
4959 ssl->state == MBEDTLS_SSL_SERVER_FINISHED) { in ssl_get_next_record()
4962 mbedtls_ssl_send_alert_message(ssl, in ssl_get_next_record()
4970 if (ssl->conf->badmac_limit != 0 && in ssl_get_next_record()
4971 ++ssl->badmac_seen >= ssl->conf->badmac_limit) { in ssl_get_next_record()
4979 ssl->next_record_offset = 0; in ssl_get_next_record()
4980 ssl->in_left = 0; in ssl_get_next_record()
4993 mbedtls_ssl_send_alert_message(ssl, in ssl_get_next_record()
5006 mbedtls_ssl_update_in_pointers(ssl); in ssl_get_next_record()
5008 ssl->in_len = ssl->in_cid + rec.cid_len; in ssl_get_next_record()
5010 ssl->in_iv = ssl->in_len + 2; in ssl_get_next_record()
5014 ssl->in_msgtype = rec.type; in ssl_get_next_record()
5019 ssl->in_hdr[0] = rec.type; in ssl_get_next_record()
5020 ssl->in_msg = rec.buf + rec.data_offset; in ssl_get_next_record()
5021 ssl->in_msglen = rec.data_len; in ssl_get_next_record()
5022 MBEDTLS_PUT_UINT16_BE(rec.data_len, ssl->in_len, 0); in ssl_get_next_record()
5027 int mbedtls_ssl_handle_message_type(mbedtls_ssl_context *ssl) in mbedtls_ssl_handle_message_type() argument
5034 if (ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE) { in mbedtls_ssl_handle_message_type()
5035 if ((ret = mbedtls_ssl_prepare_handshake_record(ssl)) != 0) { in mbedtls_ssl_handle_message_type()
5040 if (ssl->in_msgtype == MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC) { in mbedtls_ssl_handle_message_type()
5041 if (ssl->in_msglen != 1) { in mbedtls_ssl_handle_message_type()
5043 ssl->in_msglen)); in mbedtls_ssl_handle_message_type()
5047 if (ssl->in_msg[0] != 1) { in mbedtls_ssl_handle_message_type()
5049 ssl->in_msg[0])); in mbedtls_ssl_handle_message_type()
5054 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM && in mbedtls_ssl_handle_message_type()
5055 ssl->state != MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC && in mbedtls_ssl_handle_message_type()
5056 ssl->state != MBEDTLS_SSL_SERVER_CHANGE_CIPHER_SPEC) { in mbedtls_ssl_handle_message_type()
5057 if (ssl->handshake == NULL) { in mbedtls_ssl_handle_message_type()
5068 if (ssl->tls_version == MBEDTLS_SSL_VERSION_TLS1_3) { in mbedtls_ssl_handle_message_type()
5082 if (ssl->in_msgtype == MBEDTLS_SSL_MSG_ALERT) { in mbedtls_ssl_handle_message_type()
5083 if (ssl->in_msglen != 2) { in mbedtls_ssl_handle_message_type()
5088 ssl->in_msglen)); in mbedtls_ssl_handle_message_type()
5093 ssl->in_msg[0], ssl->in_msg[1])); in mbedtls_ssl_handle_message_type()
5098 if (ssl->in_msg[0] == MBEDTLS_SSL_ALERT_LEVEL_FATAL) { in mbedtls_ssl_handle_message_type()
5100 ssl->in_msg[1])); in mbedtls_ssl_handle_message_type()
5104 if (ssl->in_msg[0] == MBEDTLS_SSL_ALERT_LEVEL_WARNING && in mbedtls_ssl_handle_message_type()
5105 ssl->in_msg[1] == MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY) { in mbedtls_ssl_handle_message_type()
5111 if (ssl->in_msg[0] == MBEDTLS_SSL_ALERT_LEVEL_WARNING && in mbedtls_ssl_handle_message_type()
5112 ssl->in_msg[1] == MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION) { in mbedtls_ssl_handle_message_type()
5123 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_handle_message_type()
5126 if (ssl->in_msgtype == MBEDTLS_SSL_MSG_APPLICATION_DATA && in mbedtls_ssl_handle_message_type()
5127 mbedtls_ssl_is_handshake_over(ssl) == 0 in mbedtls_ssl_handle_message_type()
5129 && !(ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS && in mbedtls_ssl_handle_message_type()
5130 ssl->state == MBEDTLS_SSL_SERVER_HELLO) in mbedtls_ssl_handle_message_type()
5137 if (ssl->handshake != NULL && in mbedtls_ssl_handle_message_type()
5138 mbedtls_ssl_is_handshake_over(ssl) == 1) { in mbedtls_ssl_handle_message_type()
5139 mbedtls_ssl_handshake_wrapup_free_hs_transform(ssl); in mbedtls_ssl_handle_message_type()
5147 int mbedtls_ssl_send_fatal_handshake_failure(mbedtls_ssl_context *ssl) in mbedtls_ssl_send_fatal_handshake_failure() argument
5149 return mbedtls_ssl_send_alert_message(ssl, in mbedtls_ssl_send_fatal_handshake_failure()
5154 int mbedtls_ssl_send_alert_message(mbedtls_ssl_context *ssl, in mbedtls_ssl_send_alert_message() argument
5160 if (ssl == NULL || ssl->conf == NULL) { in mbedtls_ssl_send_alert_message()
5164 if (ssl->out_left != 0) { in mbedtls_ssl_send_alert_message()
5165 return mbedtls_ssl_flush_output(ssl); in mbedtls_ssl_send_alert_message()
5171 ssl->out_msgtype = MBEDTLS_SSL_MSG_ALERT; in mbedtls_ssl_send_alert_message()
5172 ssl->out_msglen = 2; in mbedtls_ssl_send_alert_message()
5173 ssl->out_msg[0] = level; in mbedtls_ssl_send_alert_message()
5174 ssl->out_msg[1] = message; in mbedtls_ssl_send_alert_message()
5176 if ((ret = mbedtls_ssl_write_record(ssl, SSL_FORCE_FLUSH)) != 0) { in mbedtls_ssl_send_alert_message()
5185 int mbedtls_ssl_write_change_cipher_spec(mbedtls_ssl_context *ssl) in mbedtls_ssl_write_change_cipher_spec() argument
5191 ssl->out_msgtype = MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC; in mbedtls_ssl_write_change_cipher_spec()
5192 ssl->out_msglen = 1; in mbedtls_ssl_write_change_cipher_spec()
5193 ssl->out_msg[0] = 1; in mbedtls_ssl_write_change_cipher_spec()
5195 ssl->state++; in mbedtls_ssl_write_change_cipher_spec()
5197 if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) { in mbedtls_ssl_write_change_cipher_spec()
5207 int mbedtls_ssl_parse_change_cipher_spec(mbedtls_ssl_context *ssl) in mbedtls_ssl_parse_change_cipher_spec() argument
5213 if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) { in mbedtls_ssl_parse_change_cipher_spec()
5218 if (ssl->in_msgtype != MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC) { in mbedtls_ssl_parse_change_cipher_spec()
5220 mbedtls_ssl_send_alert_message(ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL, in mbedtls_ssl_parse_change_cipher_spec()
5234 ssl->transform_in = ssl->transform_negotiate; in mbedtls_ssl_parse_change_cipher_spec()
5236 ssl->session_in = ssl->session_negotiate; in mbedtls_ssl_parse_change_cipher_spec()
5239 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_parse_change_cipher_spec()
5241 mbedtls_ssl_dtls_replay_reset(ssl); in mbedtls_ssl_parse_change_cipher_spec()
5245 if (++ssl->in_epoch == 0) { in mbedtls_ssl_parse_change_cipher_spec()
5253 memset(ssl->in_ctr, 0, MBEDTLS_SSL_SEQUENCE_NUMBER_LEN); in mbedtls_ssl_parse_change_cipher_spec()
5255 mbedtls_ssl_update_in_pointers(ssl); in mbedtls_ssl_parse_change_cipher_spec()
5257 ssl->state++; in mbedtls_ssl_parse_change_cipher_spec()
5278 void mbedtls_ssl_update_out_pointers(mbedtls_ssl_context *ssl, in mbedtls_ssl_update_out_pointers() argument
5282 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_update_out_pointers()
5283 ssl->out_ctr = ssl->out_hdr + 3; in mbedtls_ssl_update_out_pointers()
5285 ssl->out_cid = ssl->out_ctr + MBEDTLS_SSL_SEQUENCE_NUMBER_LEN; in mbedtls_ssl_update_out_pointers()
5286 ssl->out_len = ssl->out_cid; in mbedtls_ssl_update_out_pointers()
5288 ssl->out_len += transform->out_cid_len; in mbedtls_ssl_update_out_pointers()
5291 ssl->out_len = ssl->out_ctr + MBEDTLS_SSL_SEQUENCE_NUMBER_LEN; in mbedtls_ssl_update_out_pointers()
5293 ssl->out_iv = ssl->out_len + 2; in mbedtls_ssl_update_out_pointers()
5297 ssl->out_len = ssl->out_hdr + 3; in mbedtls_ssl_update_out_pointers()
5299 ssl->out_cid = ssl->out_len; in mbedtls_ssl_update_out_pointers()
5301 ssl->out_iv = ssl->out_hdr + 5; in mbedtls_ssl_update_out_pointers()
5304 ssl->out_msg = ssl->out_iv; in mbedtls_ssl_update_out_pointers()
5307 ssl->out_msg += ssl_transform_get_explicit_iv_len(transform); in mbedtls_ssl_update_out_pointers()
5319 void mbedtls_ssl_update_in_pointers(mbedtls_ssl_context *ssl) in mbedtls_ssl_update_in_pointers() argument
5332 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_update_in_pointers()
5337 ssl->in_ctr = ssl->in_hdr + 3; in mbedtls_ssl_update_in_pointers()
5339 ssl->in_cid = ssl->in_ctr + MBEDTLS_SSL_SEQUENCE_NUMBER_LEN; in mbedtls_ssl_update_in_pointers()
5340 ssl->in_len = ssl->in_cid; /* Default: no CID */ in mbedtls_ssl_update_in_pointers()
5342 ssl->in_len = ssl->in_ctr + MBEDTLS_SSL_SEQUENCE_NUMBER_LEN; in mbedtls_ssl_update_in_pointers()
5344 ssl->in_iv = ssl->in_len + 2; in mbedtls_ssl_update_in_pointers()
5348 ssl->in_ctr = ssl->in_hdr - MBEDTLS_SSL_SEQUENCE_NUMBER_LEN; in mbedtls_ssl_update_in_pointers()
5349 ssl->in_len = ssl->in_hdr + 3; in mbedtls_ssl_update_in_pointers()
5351 ssl->in_cid = ssl->in_len; in mbedtls_ssl_update_in_pointers()
5353 ssl->in_iv = ssl->in_hdr + 5; in mbedtls_ssl_update_in_pointers()
5357 ssl->in_msg = ssl->in_iv; in mbedtls_ssl_update_in_pointers()
5364 void mbedtls_ssl_reset_in_out_pointers(mbedtls_ssl_context *ssl) in mbedtls_ssl_reset_in_out_pointers() argument
5368 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_reset_in_out_pointers()
5369 ssl->out_hdr = ssl->out_buf; in mbedtls_ssl_reset_in_out_pointers()
5370 ssl->in_hdr = ssl->in_buf; in mbedtls_ssl_reset_in_out_pointers()
5374 ssl->out_ctr = ssl->out_buf; in mbedtls_ssl_reset_in_out_pointers()
5375 ssl->out_hdr = ssl->out_buf + 8; in mbedtls_ssl_reset_in_out_pointers()
5376 ssl->in_hdr = ssl->in_buf + 8; in mbedtls_ssl_reset_in_out_pointers()
5380 mbedtls_ssl_update_out_pointers(ssl, NULL /* no transform enabled */); in mbedtls_ssl_reset_in_out_pointers()
5381 mbedtls_ssl_update_in_pointers(ssl); in mbedtls_ssl_reset_in_out_pointers()
5387 size_t mbedtls_ssl_get_bytes_avail(const mbedtls_ssl_context *ssl) in mbedtls_ssl_get_bytes_avail() argument
5389 return ssl->in_offt == NULL ? 0 : ssl->in_msglen; in mbedtls_ssl_get_bytes_avail()
5392 int mbedtls_ssl_check_pending(const mbedtls_ssl_context *ssl) in mbedtls_ssl_check_pending() argument
5399 if (ssl->keep_current_message == 1) { in mbedtls_ssl_check_pending()
5409 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM && in mbedtls_ssl_check_pending()
5410 ssl->in_left > ssl->next_record_offset) { in mbedtls_ssl_check_pending()
5420 if (ssl->in_hslen > 0 && ssl->in_hslen < ssl->in_msglen) { in mbedtls_ssl_check_pending()
5429 if (ssl->in_offt != NULL) { in mbedtls_ssl_check_pending()
5445 int mbedtls_ssl_get_record_expansion(const mbedtls_ssl_context *ssl) in mbedtls_ssl_get_record_expansion() argument
5448 const mbedtls_ssl_transform *transform = ssl->transform_out; in mbedtls_ssl_get_record_expansion()
5455 size_t out_hdr_len = mbedtls_ssl_out_hdr_len(ssl); in mbedtls_ssl_get_record_expansion()
5543 static int ssl_check_ctr_renegotiate(mbedtls_ssl_context *ssl) in ssl_check_ctr_renegotiate() argument
5545 size_t ep_len = mbedtls_ssl_ep_len(ssl); in ssl_check_ctr_renegotiate()
5549 if (mbedtls_ssl_is_handshake_over(ssl) == 0 || in ssl_check_ctr_renegotiate()
5550 ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING || in ssl_check_ctr_renegotiate()
5551 ssl->conf->disable_renegotiation == MBEDTLS_SSL_RENEGOTIATION_DISABLED) { in ssl_check_ctr_renegotiate()
5555 in_ctr_cmp = memcmp(ssl->in_ctr + ep_len, in ssl_check_ctr_renegotiate()
5556 &ssl->conf->renego_period[ep_len], in ssl_check_ctr_renegotiate()
5558 out_ctr_cmp = memcmp(&ssl->cur_out_ctr[ep_len], in ssl_check_ctr_renegotiate()
5559 &ssl->conf->renego_period[ep_len], in ssl_check_ctr_renegotiate()
5560 sizeof(ssl->cur_out_ctr) - ep_len); in ssl_check_ctr_renegotiate()
5567 return mbedtls_ssl_renegotiate(ssl); in ssl_check_ctr_renegotiate()
5575 static int ssl_tls13_is_new_session_ticket(mbedtls_ssl_context *ssl) in ssl_tls13_is_new_session_ticket() argument
5578 if ((ssl->in_hslen == mbedtls_ssl_hs_hdr_len(ssl)) || in ssl_tls13_is_new_session_ticket()
5579 (ssl->in_msg[0] != MBEDTLS_SSL_HS_NEW_SESSION_TICKET)) { in ssl_tls13_is_new_session_ticket()
5588 static int ssl_tls13_handle_hs_message_post_handshake(mbedtls_ssl_context *ssl) in ssl_tls13_handle_hs_message_post_handshake() argument
5594 if (ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT) { in ssl_tls13_handle_hs_message_post_handshake()
5595 if (ssl_tls13_is_new_session_ticket(ssl)) { in ssl_tls13_handle_hs_message_post_handshake()
5598 if (mbedtls_ssl_conf_is_signal_new_session_tickets_enabled(ssl->conf) == in ssl_tls13_handle_hs_message_post_handshake()
5600 ssl->keep_current_message = 1; in ssl_tls13_handle_hs_message_post_handshake()
5602 mbedtls_ssl_handshake_set_state(ssl, in ssl_tls13_handle_hs_message_post_handshake()
5633 static int ssl_tls12_handle_hs_message_post_handshake(mbedtls_ssl_context *ssl) in ssl_tls12_handle_hs_message_post_handshake() argument
5644 if (ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT && in ssl_tls12_handle_hs_message_post_handshake()
5645 (ssl->in_msg[0] != MBEDTLS_SSL_HS_HELLO_REQUEST || in ssl_tls12_handle_hs_message_post_handshake()
5646 ssl->in_hslen != mbedtls_ssl_hs_hdr_len(ssl))) { in ssl_tls12_handle_hs_message_post_handshake()
5651 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_tls12_handle_hs_message_post_handshake()
5660 if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER && in ssl_tls12_handle_hs_message_post_handshake()
5661 ssl->in_msg[0] != MBEDTLS_SSL_HS_CLIENT_HELLO) { in ssl_tls12_handle_hs_message_post_handshake()
5666 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_tls12_handle_hs_message_post_handshake()
5676 if (!(ssl->conf->disable_renegotiation == MBEDTLS_SSL_RENEGOTIATION_DISABLED || in ssl_tls12_handle_hs_message_post_handshake()
5677 (ssl->secure_renegotiation == MBEDTLS_SSL_LEGACY_RENEGOTIATION && in ssl_tls12_handle_hs_message_post_handshake()
5678 ssl->conf->allow_legacy_renegotiation == in ssl_tls12_handle_hs_message_post_handshake()
5686 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM && in ssl_tls12_handle_hs_message_post_handshake()
5687 ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT) { in ssl_tls12_handle_hs_message_post_handshake()
5688 ssl->renego_status = MBEDTLS_SSL_RENEGOTIATION_PENDING; in ssl_tls12_handle_hs_message_post_handshake()
5691 ret = mbedtls_ssl_start_renegotiation(ssl); in ssl_tls12_handle_hs_message_post_handshake()
5707 if ((ret = mbedtls_ssl_send_alert_message(ssl, in ssl_tls12_handle_hs_message_post_handshake()
5719 static int ssl_handle_hs_message_post_handshake(mbedtls_ssl_context *ssl) in ssl_handle_hs_message_post_handshake() argument
5723 if (ssl->tls_version == MBEDTLS_SSL_VERSION_TLS1_3) { in ssl_handle_hs_message_post_handshake()
5724 return ssl_tls13_handle_hs_message_post_handshake(ssl); in ssl_handle_hs_message_post_handshake()
5729 if (ssl->tls_version <= MBEDTLS_SSL_VERSION_TLS1_2) { in ssl_handle_hs_message_post_handshake()
5730 return ssl_tls12_handle_hs_message_post_handshake(ssl); in ssl_handle_hs_message_post_handshake()
5755 mbedtls_ssl_context *ssl, unsigned char *buf, size_t len) in ssl_read_application_data() argument
5757 size_t n = (len < ssl->in_msglen) ? len : ssl->in_msglen; in ssl_read_application_data()
5760 memcpy(buf, ssl->in_offt, n); in ssl_read_application_data()
5761 ssl->in_msglen -= n; in ssl_read_application_data()
5766 mbedtls_platform_zeroize(ssl->in_offt, n); in ssl_read_application_data()
5768 if (ssl->in_msglen == 0) { in ssl_read_application_data()
5770 ssl->in_offt = NULL; in ssl_read_application_data()
5771 ssl->keep_current_message = 0; in ssl_read_application_data()
5774 ssl->in_offt += n; in ssl_read_application_data()
5783 int mbedtls_ssl_read(mbedtls_ssl_context *ssl, unsigned char *buf, size_t len) in mbedtls_ssl_read() argument
5787 if (ssl == NULL || ssl->conf == NULL) { in mbedtls_ssl_read()
5794 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in mbedtls_ssl_read()
5795 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) { in mbedtls_ssl_read()
5799 if (ssl->handshake != NULL && in mbedtls_ssl_read()
5800 ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING) { in mbedtls_ssl_read()
5801 if ((ret = mbedtls_ssl_flight_transmit(ssl)) != 0) { in mbedtls_ssl_read()
5821 ret = ssl_check_ctr_renegotiate(ssl); in mbedtls_ssl_read()
5829 if (ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER) { in mbedtls_ssl_read()
5830 ret = mbedtls_ssl_handshake(ssl); in mbedtls_ssl_read()
5839 while (ssl->in_offt == NULL) { in mbedtls_ssl_read()
5841 if (ssl->f_get_timer != NULL && in mbedtls_ssl_read()
5842 ssl->f_get_timer(ssl->p_timer) == -1) { in mbedtls_ssl_read()
5843 mbedtls_ssl_set_timer(ssl, ssl->conf->read_timeout); in mbedtls_ssl_read()
5846 if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) { in mbedtls_ssl_read()
5855 if (ssl->in_msglen == 0 && in mbedtls_ssl_read()
5856 ssl->in_msgtype == MBEDTLS_SSL_MSG_APPLICATION_DATA) { in mbedtls_ssl_read()
5860 if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) { in mbedtls_ssl_read()
5870 if (ssl->in_msgtype == MBEDTLS_SSL_MSG_HANDSHAKE) { in mbedtls_ssl_read()
5871 ret = ssl_handle_hs_message_post_handshake(ssl); in mbedtls_ssl_read()
5902 else if (ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING) { in mbedtls_ssl_read()
5903 if (ssl->conf->renego_max_records >= 0) { in mbedtls_ssl_read()
5904 if (++ssl->renego_records_seen > ssl->conf->renego_max_records) { in mbedtls_ssl_read()
5914 if (ssl->in_msgtype == MBEDTLS_SSL_MSG_ALERT) { in mbedtls_ssl_read()
5919 if (ssl->in_msgtype != MBEDTLS_SSL_MSG_APPLICATION_DATA) { in mbedtls_ssl_read()
5924 ssl->in_offt = ssl->in_msg; in mbedtls_ssl_read()
5928 if (mbedtls_ssl_is_handshake_over(ssl) == 1) { in mbedtls_ssl_read()
5929 mbedtls_ssl_set_timer(ssl, 0); in mbedtls_ssl_read()
5937 if (ssl->conf->endpoint == MBEDTLS_SSL_IS_SERVER && in mbedtls_ssl_read()
5938 ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING) { in mbedtls_ssl_read()
5939 if ((ret = mbedtls_ssl_resend_hello_request(ssl)) != 0) { in mbedtls_ssl_read()
5949 ret = ssl_read_application_data(ssl, buf, len); in mbedtls_ssl_read()
5957 int mbedtls_ssl_read_early_data(mbedtls_ssl_context *ssl, in mbedtls_ssl_read_early_data() argument
5960 if (ssl == NULL || (ssl->conf == NULL)) { in mbedtls_ssl_read_early_data()
5968 if ((ssl->state != MBEDTLS_SSL_END_OF_EARLY_DATA) || in mbedtls_ssl_read_early_data()
5969 (ssl->in_offt == NULL)) { in mbedtls_ssl_read_early_data()
5973 return ssl_read_application_data(ssl, buf, len); in mbedtls_ssl_read_early_data()
5990 static int ssl_write_real(mbedtls_ssl_context *ssl, in ssl_write_real() argument
5993 int ret = mbedtls_ssl_get_max_out_record_payload(ssl); in ssl_write_real()
6003 if (ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM) { in ssl_write_real()
6014 if (ssl->out_left != 0) { in ssl_write_real()
6021 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) { in ssl_write_real()
6031 ssl->out_msglen = len; in ssl_write_real()
6032 ssl->out_msgtype = MBEDTLS_SSL_MSG_APPLICATION_DATA; in ssl_write_real()
6034 memcpy(ssl->out_msg, buf, len); in ssl_write_real()
6037 if ((ret = mbedtls_ssl_write_record(ssl, SSL_FORCE_FLUSH)) != 0) { in ssl_write_real()
6049 int mbedtls_ssl_write(mbedtls_ssl_context *ssl, const unsigned char *buf, size_t len) in mbedtls_ssl_write() argument
6055 if (ssl == NULL || ssl->conf == NULL) { in mbedtls_ssl_write()
6060 if ((ret = ssl_check_ctr_renegotiate(ssl)) != 0) { in mbedtls_ssl_write()
6066 if (ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER) { in mbedtls_ssl_write()
6067 if ((ret = mbedtls_ssl_handshake(ssl)) != 0) { in mbedtls_ssl_write()
6073 ret = ssl_write_real(ssl, buf, len); in mbedtls_ssl_write()
6081 int mbedtls_ssl_write_early_data(mbedtls_ssl_context *ssl, in mbedtls_ssl_write_early_data() argument
6090 if (ssl == NULL || (conf = ssl->conf) == NULL) { in mbedtls_ssl_write_early_data()
6104 if (ssl->tls_version != MBEDTLS_SSL_VERSION_TLS1_3) { in mbedtls_ssl_write_early_data()
6120 if ((ssl->early_data_state == MBEDTLS_SSL_EARLY_DATA_STATE_IDLE) || in mbedtls_ssl_write_early_data()
6121 (ssl->early_data_state == MBEDTLS_SSL_EARLY_DATA_STATE_IND_SENT)) { in mbedtls_ssl_write_early_data()
6122 while ((ssl->early_data_state == MBEDTLS_SSL_EARLY_DATA_STATE_IDLE) || in mbedtls_ssl_write_early_data()
6123 (ssl->early_data_state == MBEDTLS_SSL_EARLY_DATA_STATE_IND_SENT)) { in mbedtls_ssl_write_early_data()
6124 ret = mbedtls_ssl_handshake_step(ssl); in mbedtls_ssl_write_early_data()
6130 ret = mbedtls_ssl_flush_output(ssl); in mbedtls_ssl_write_early_data()
6136 remaining = ssl->session_negotiate->max_early_data_size; in mbedtls_ssl_write_early_data()
6145 if ((ssl->early_data_state != MBEDTLS_SSL_EARLY_DATA_STATE_CAN_WRITE) && in mbedtls_ssl_write_early_data()
6146 (ssl->early_data_state != MBEDTLS_SSL_EARLY_DATA_STATE_ACCEPTED)) { in mbedtls_ssl_write_early_data()
6150 remaining = ssl->session_negotiate->max_early_data_size - in mbedtls_ssl_write_early_data()
6151 ssl->total_early_data_size; in mbedtls_ssl_write_early_data()
6157 ret = mbedtls_ssl_handshake(ssl); in mbedtls_ssl_write_early_data()
6164 if (((ssl->early_data_state != MBEDTLS_SSL_EARLY_DATA_STATE_CAN_WRITE) && in mbedtls_ssl_write_early_data()
6165 (ssl->early_data_state != MBEDTLS_SSL_EARLY_DATA_STATE_ACCEPTED)) in mbedtls_ssl_write_early_data()
6174 ret = ssl_write_real(ssl, buf, len); in mbedtls_ssl_write_early_data()
6176 ssl->total_early_data_size += ret; in mbedtls_ssl_write_early_data()
6188 int mbedtls_ssl_close_notify(mbedtls_ssl_context *ssl) in mbedtls_ssl_close_notify() argument
6192 if (ssl == NULL || ssl->conf == NULL) { in mbedtls_ssl_close_notify()
6198 if (mbedtls_ssl_is_handshake_over(ssl) == 1) { in mbedtls_ssl_close_notify()
6199 if ((ret = mbedtls_ssl_send_alert_message(ssl, in mbedtls_ssl_close_notify()
6239 void mbedtls_ssl_set_inbound_transform(mbedtls_ssl_context *ssl, in mbedtls_ssl_set_inbound_transform() argument
6242 ssl->transform_in = transform; in mbedtls_ssl_set_inbound_transform()
6243 memset(ssl->in_ctr, 0, MBEDTLS_SSL_SEQUENCE_NUMBER_LEN); in mbedtls_ssl_set_inbound_transform()
6246 void mbedtls_ssl_set_outbound_transform(mbedtls_ssl_context *ssl, in mbedtls_ssl_set_outbound_transform() argument
6249 ssl->transform_out = transform; in mbedtls_ssl_set_outbound_transform()
6250 memset(ssl->cur_out_ctr, 0, sizeof(ssl->cur_out_ctr)); in mbedtls_ssl_set_outbound_transform()
6255 void mbedtls_ssl_buffering_free(mbedtls_ssl_context *ssl) in mbedtls_ssl_buffering_free() argument
6258 mbedtls_ssl_handshake_params * const hs = ssl->handshake; in mbedtls_ssl_buffering_free()
6264 ssl_free_buffered_record(ssl); in mbedtls_ssl_buffering_free()
6267 ssl_buffering_free_slot(ssl, offset); in mbedtls_ssl_buffering_free()
6271 static void ssl_buffering_free_slot(mbedtls_ssl_context *ssl, in ssl_buffering_free_slot() argument
6274 mbedtls_ssl_handshake_params * const hs = ssl->handshake; in ssl_buffering_free_slot()
6338 int mbedtls_ssl_handle_pending_alert(mbedtls_ssl_context *ssl) in mbedtls_ssl_handle_pending_alert() argument
6343 if (ssl->send_alert == 0) { in mbedtls_ssl_handle_pending_alert()
6347 ret = mbedtls_ssl_send_alert_message(ssl, in mbedtls_ssl_handle_pending_alert()
6349 ssl->alert_type); in mbedtls_ssl_handle_pending_alert()
6355 ssl->send_alert = 0; in mbedtls_ssl_handle_pending_alert()
6362 return ssl->alert_reason; in mbedtls_ssl_handle_pending_alert()
6368 void mbedtls_ssl_pend_fatal_alert(mbedtls_ssl_context *ssl, in mbedtls_ssl_pend_fatal_alert() argument
6372 ssl->send_alert = 1; in mbedtls_ssl_pend_fatal_alert()
6373 ssl->alert_type = alert_type; in mbedtls_ssl_pend_fatal_alert()
6374 ssl->alert_reason = alert_reason; in mbedtls_ssl_pend_fatal_alert()