mbedtls_ssl_context::handshake field

if (ssl->handshake->resume) {

ssl_client.c:777

ssl->handshake->min_tls_version = ssl->tls_version;

ssl_client.c:779

ssl->handshake->min_tls_version = ssl->conf->min_tls_version;

ssl_client.c:781

(ssl->handshake->cookie == NULL))

ssl_client.c:792

ssl->handshake->resume == 0) {

ssl_client.c:821

mbedtls_ssl_write_client_hello()

ret = ssl->handshake->update_checksum(ssl, buf, msg_len - binders_len);

ssl_client.c:968

if (ssl->handshake->psk != NULL && ssl->handshake->psk_len > 0) {

ssl_misc.h:1545

*psk = ssl->handshake->psk;

ssl_misc.h:1546

*psk_len = ssl->handshake->psk_len;

ssl_misc.h:1547

if (ssl->handshake != NULL && ssl->handshake->key_cert != NULL) {

ssl_misc.h:1654

mbedtls_ssl_own_key()

key_cert = ssl->handshake->key_cert;

ssl_misc.h:1655

mbedtls_ssl_own_key()

if (ssl->handshake != NULL && ssl->handshake->key_cert != NULL) {

ssl_misc.h:1667

mbedtls_ssl_own_cert()

key_cert = ssl->handshake->key_cert;

ssl_misc.h:1668

mbedtls_ssl_own_cert()

if (ssl->handshake->retransmit_timeout >= ssl->conf->hs_timeout_max) {

ssl_msg.c:485

if (ssl->handshake->retransmit_timeout != ssl->conf->hs_timeout_min) {

ssl_msg.c:495

ssl->handshake->mtu = 508;

ssl_msg.c:496

new_timeout = 2 * ssl->handshake->retransmit_timeout;

ssl_msg.c:500

if (new_timeout < ssl->handshake->retransmit_timeout ||

ssl_msg.c:503

ssl->handshake->retransmit_timeout = new_timeout;

ssl_msg.c:508

ssl_reset_retransmit_timeout()

ssl->handshake->retransmit_timeout = ssl->conf->hs_timeout_min;

ssl_msg.c:517

timeout = ssl->handshake->retransmit_timeout;

ssl_msg.c:2235

mbedtls_ssl_fetch_input()

if (ssl->handshake->flight == NULL) {

ssl_msg.c:2442

ssl->handshake->flight = msg;

ssl_msg.c:2443

mbedtls_ssl_flight_item *cur = ssl->handshake->flight;

ssl_msg.c:2445

if (ssl->transform_out == ssl->handshake->alt_transform_out) {

ssl_msg.c:2483

ssl->transform_out = ssl->handshake->alt_transform_out;

ssl_msg.c:2492

ssl->handshake->alt_transform_out = tmp_transform;

ssl_msg.c:2493

memcpy(ssl->cur_out_ctr, ssl->handshake->alt_out_ctr,

ssl_msg.c:2497

memcpy(ssl->handshake->alt_out_ctr, tmp_out_ctr,

ssl_msg.c:2499

sizeof(ssl->handshake->alt_out_ctr));

ssl_msg.c:2500

if (ssl->handshake->retransmit_state != MBEDTLS_SSL_RETRANS_SENDING) {

ssl_msg.c:2536

ssl->handshake->cur_msg = ssl->handshake->flight;

ssl_msg.c:2539

ssl->handshake->cur_msg_p = ssl->handshake->flight->p + 12;

ssl_msg.c:2540

ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_SENDING;

ssl_msg.c:2546

while (ssl->handshake->cur_msg != NULL) {

ssl_msg.c:2549

const mbedtls_ssl_flight_item * const cur = ssl->handshake->cur_msg;

ssl_msg.c:2551

if (is_finished && ssl->handshake->cur_msg_p == (cur->p + 12)) {

ssl_msg.c:2563

ssl->handshake->cur_msg_p += cur->len;

ssl_msg.c:2592

const unsigned char * const p = ssl->handshake->cur_msg_p;

ssl_msg.c:2594

ssl->handshake->cur_msg_p += cur_hs_frag_len;

ssl_msg.c:2646

if (ssl->handshake->cur_msg_p >= cur->p + cur->len) {

ssl_msg.c:2650

ssl->handshake->cur_msg = cur->next;

ssl_msg.c:2652

ssl->handshake->cur_msg_p = cur->next->p + 12;

ssl_msg.c:2653

ssl->handshake->cur_msg = NULL;

ssl_msg.c:2655

ssl->handshake->cur_msg_p = NULL;

ssl_msg.c:2656

ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_FINISHED;

ssl_msg.c:2673

ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_WAITING;

ssl_msg.c:2675

mbedtls_ssl_set_timer(ssl, ssl->handshake->retransmit_timeout);

ssl_msg.c:2676

mbedtls_ssl_flight_free(ssl->handshake->flight);

ssl_msg.c:2690

ssl->handshake->flight = NULL;

ssl_msg.c:2691

ssl->handshake->cur_msg = NULL;

ssl_msg.c:2692

ssl->handshake->in_flight_start_seq = ssl->handshake->in_msg_seq;

ssl_msg.c:2695

ssl->handshake->buffering.seen_ccs = 0;

ssl_msg.c:2698

ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_FINISHED;

ssl_msg.c:2708

ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_PREPARING;

ssl_msg.c:2710

mbedtls_ssl_set_timer(ssl, ssl->handshake->retransmit_timeout);

ssl_msg.c:2720

ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_FINISHED;

ssl_msg.c:2724

ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_WAITING;

ssl_msg.c:2726

ssl->handshake == NULL) {

ssl_msg.c:2798

ssl->handshake != NULL &&

ssl_msg.c:2805

ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING) {

ssl_msg.c:2806

MBEDTLS_PUT_UINT16_BE(ssl->handshake->out_msg_seq, ssl->out_msg, 4);

ssl_msg.c:2861

++(ssl->handshake->out_msg_seq);

ssl_msg.c:2862

ret = ssl->handshake->update_checksum(ssl, ssl->out_msg,

ssl_msg.c:2877

if (ssl->handshake != NULL &&

ssl_msg.c:3246

recv_msg_seq != ssl->handshake->in_msg_seq) ||

ssl_msg.c:3248

if (recv_msg_seq > ssl->handshake->in_msg_seq) {

ssl_msg.c:3251

if (recv_msg_seq == ssl->handshake->in_flight_start_seq - 1 &&

ssl_msg.c:3263

mbedtls_ssl_handshake_params * const hs = ssl->handshake;

ssl_msg.c:3307

ret = ssl->handshake->update_checksum(ssl, ssl->in_msg, ssl->in_hslen);

ssl_msg.c:3310

ssl->handshake != NULL) {

ssl_msg.c:3320

ssl_load_buffered_message()

mbedtls_ssl_handshake_params * const hs = ssl->handshake;

ssl_msg.c:4280

mbedtls_ssl_handshake_params * const hs = ssl->handshake;

ssl_msg.c:4371

ssl_buffer_make_space()

mbedtls_ssl_handshake_params * const hs = ssl->handshake;

ssl_msg.c:4412

if (recv_msg_seq < ssl->handshake->in_msg_seq) {

ssl_msg.c:4436

recv_msg_seq_offset = recv_msg_seq - ssl->handshake->in_msg_seq;

ssl_msg.c:4441

ssl_free_buffered_record()

mbedtls_ssl_handshake_params * const hs = ssl->handshake;

ssl_msg.c:4703

mbedtls_ssl_handshake_params * const hs = ssl->handshake;

ssl_msg.c:4720

ssl_load_buffered_record()

mbedtls_ssl_handshake_params * const hs = ssl->handshake;

ssl_msg.c:4781

ssl_buffer_future_record()

if (ssl->handshake == NULL) {

ssl_msg.c:5057

mbedtls_ssl_handle_message_type()

if (ssl->handshake != NULL &&

ssl_msg.c:5137

mbedtls_ssl_handle_message_type()

if (ssl->handshake != NULL &&

ssl_msg.c:5799

mbedtls_ssl_read()

ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING) {

ssl_msg.c:5800

mbedtls_ssl_read()

mbedtls_ssl_handshake_params * const hs = ssl->handshake;

ssl_msg.c:6258

mbedtls_ssl_buffering_free()

mbedtls_ssl_handshake_params * const hs = ssl->handshake;

ssl_msg.c:6274

ssl_buffering_free_slot()

ssl->handshake->update_checksum = ssl_update_checksum_sha384;

ssl_tls.c:789

mbedtls_ssl_optimize_checksum()

ssl->handshake->update_checksum = ssl_update_checksum_sha256;

ssl_tls.c:794

mbedtls_ssl_optimize_checksum()

return ssl->handshake->update_checksum(ssl, hs_hdr, sizeof(hs_hdr));

ssl_tls.c:815

mbedtls_ssl_add_hs_hdr_to_checksum()

return ssl->handshake->update_checksum(ssl, msg, msg_len);

ssl_tls.c:828

mbedtls_ssl_add_hs_msg_to_checksum()

mbedtls_md_free(&ssl->handshake->fin_sha256);

ssl_tls.c:854

mbedtls_md_init(&ssl->handshake->fin_sha256);

ssl_tls.c:855

ret = mbedtls_md_setup(&ssl->handshake->fin_sha256,

ssl_tls.c:856

ret = mbedtls_md_starts(&ssl->handshake->fin_sha256);

ssl_tls.c:862

mbedtls_md_free(&ssl->handshake->fin_sha384);

ssl_tls.c:879

mbedtls_md_init(&ssl->handshake->fin_sha384);

ssl_tls.c:880

ret = mbedtls_md_setup(&ssl->handshake->fin_sha384,

ssl_tls.c:881

ret = mbedtls_md_starts(&ssl->handshake->fin_sha384);

ssl_tls.c:886

ssl_update_checksum_start()

ret = mbedtls_md_update(&ssl->handshake->fin_sha256, buf, len);

ssl_tls.c:917

ret = mbedtls_md_update(&ssl->handshake->fin_sha384, buf, len);

ssl_tls.c:930

ssl_update_checksum_start()

return mbedtls_md_update(&ssl->handshake->fin_sha256, buf, len);

ssl_tls.c:947

ssl_update_checksum_sha256()

return mbedtls_md_update(&ssl->handshake->fin_sha384, buf, len);

ssl_tls.c:960

ssl_update_checksum_sha384()

if (ssl->handshake) {

ssl_tls.c:1062

if (ssl->handshake == NULL) {

ssl_tls.c:1080

ssl->handshake = mbedtls_calloc(1, sizeof(mbedtls_ssl_handshake_params));

ssl_tls.c:1081

if (ssl->handshake == NULL ||

ssl_tls.c:1091

mbedtls_free(ssl->handshake);

ssl_tls.c:1098

ssl->handshake = NULL;

ssl_tls.c:1099

ssl_handshake_params_init(ssl->handshake);

ssl_tls.c:1124

ssl->handshake->alt_transform_out = ssl->transform_out;

ssl_tls.c:1146

ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_PREPARING;

ssl_tls.c:1149

ssl->handshake->retransmit_state = MBEDTLS_SSL_RETRANS_WAITING;

ssl_tls.c:1151

mbedtls_ssl_set_session()

if (ssl->handshake->resume == 1) {

ssl_tls.c:1734

ssl->handshake->resume = 1;

ssl_tls.c:1767

mbedtls_ssl_set_session()

*name_len = ssl->handshake->sni_name_len;

ssl_tls.c:1902

mbedtls_ssl_get_hs_sni()

return ssl->handshake->sni_name;

ssl_tls.c:1903

mbedtls_ssl_get_hs_sni()

return ssl_append_key_cert(&ssl->handshake->sni_key_cert,

ssl_tls.c:1910

mbedtls_ssl_set_hs_own_cert()

ssl->handshake->sni_ca_chain = ca_chain;

ssl_tls.c:1918

mbedtls_ssl_set_hs_ca_chain()

ssl->handshake->sni_ca_crl = ca_crl;

ssl_tls.c:1919

mbedtls_ssl_set_hs_ca_chain()

ssl->handshake->dn_hints = crt;

ssl_tls.c:1926

mbedtls_ssl_set_hs_dn_hints()

ssl->handshake->sni_authmode = authmode;

ssl_tls.c:1933

mbedtls_ssl_set_hs_authmode()

if (ssl->handshake == NULL || ssl->conf == NULL) {

ssl_tls.c:2072

mbedtls_ssl_set_hs_ecjpake_password()

return mbedtls_ecjpake_setup(&ssl->handshake->ecjpake_ctx,

ssl_tls.c:2087

mbedtls_ssl_set_hs_ecjpake_password()

if (ssl->handshake->psk != NULL) {

ssl_tls.c:2219

mbedtls_zeroize_and_free(ssl->handshake->psk,

ssl_tls.c:2220

ssl->handshake->psk_len);

ssl_tls.c:2221

ssl->handshake->psk_len = 0;

ssl_tls.c:2222

ssl->handshake->psk = NULL;

ssl_tls.c:2223

if (psk == NULL || ssl->handshake == NULL) {

ssl_tls.c:2238

if ((ssl->handshake->psk = mbedtls_calloc(1, psk_len)) == NULL) {

ssl_tls.c:2280

ssl->handshake->psk_len = psk_len;

ssl_tls.c:2284

memcpy(ssl->handshake->psk, psk, ssl->handshake->psk_len);

ssl_tls.c:2285

if (ssl->handshake == NULL || ssl->handshake->mtu == 0) {

ssl_tls.c:3227

return ssl->handshake->mtu;

ssl_tls.c:3232

return ssl->mtu < ssl->handshake->mtu ?

ssl_tls.c:3235

ssl->mtu : ssl->handshake->mtu;

ssl_tls.c:3236

ssl_prepare_handshake_step()

ssl->handshake->retransmit_state == MBEDTLS_SSL_RETRANS_SENDING) {

ssl_tls.c:4488

ssl->handshake == NULL ||

ssl_tls.c:4504

mbedtls_ssl_handshake_step()

ssl->handshake->out_msg_seq = 1;

ssl_tls.c:4674

mbedtls_ssl_start_renegotiation()

ssl->handshake->in_msg_seq = 1;

ssl_tls.c:4676

mbedtls_ssl_start_renegotiation()

mbedtls_ssl_handshake_params *handshake = ssl->handshake;

ssl_tls.c:4752

mbedtls_ssl_handshake_free()

if (ssl->handshake) {

ssl_tls.c:5550

mbedtls_ssl_free()

mbedtls_free(ssl->handshake);

ssl_tls.c:5552

mbedtls_ssl_free()

ret = mbedtls_md_clone(&sha384, &ssl->handshake->fin_sha384);

ssl_tls.c:6445

ssl_get_handshake_transcript_sha384()

ret = mbedtls_md_clone(&sha256, &ssl->handshake->fin_sha256);

ssl_tls.c:6483

ssl_get_handshake_transcript_sha256()

memset(ssl->handshake->received_sig_algs, 0,

ssl_tls.c:6590

sizeof(ssl->handshake->received_sig_algs));

ssl_tls.c:6591

ssl->handshake->received_sig_algs[common_idx] = sig_alg;

ssl_tls.c:6614

ssl->handshake->received_sig_algs[common_idx] = MBEDTLS_TLS_SIG_NONE;

ssl_tls.c:6634

ssl->handshake->ciphersuite_info;

ssl_tls.c:7169

ret = ssl_set_handshake_prfs(ssl->handshake,

ssl_tls.c:7174

ret = ssl_compute_master(ssl->handshake,

ssl_tls.c:7182

memcpy(tmp, ssl->handshake->randbytes, 64);

ssl_tls.c:7195

memcpy(ssl->handshake->randbytes, tmp + 32, 32);

ssl_tls.c:7196

memcpy(ssl->handshake->randbytes + 32, tmp, 32);

ssl_tls.c:7197

ssl->handshake->tls_prf,

ssl_tls.c:7208

ssl->handshake->randbytes,

ssl_tls.c:7209

mbedtls_platform_zeroize(ssl->handshake->randbytes,

ssl_tls.c:7219

sizeof(ssl->handshake->randbytes));

ssl_tls.c:7220

mbedtls_ssl_set_calc_verify_md()

ssl->handshake->calc_verify = ssl_calc_verify_tls_sha384;

ssl_tls.c:7232

ssl->handshake->calc_verify = ssl_calc_verify_tls_sha256;

ssl_tls.c:7237

mbedtls_ssl_set_calc_verify_md()

return ssl_calc_verify_tls_legacy(ssl, &ssl->handshake->fin_sha256,

ssl_tls.c:7331

ssl_calc_verify_tls_sha256()

return ssl_calc_verify_tls_legacy(ssl, &ssl->handshake->fin_sha384,

ssl_tls.c:7346

ssl_calc_verify_tls_sha384()

unsigned char *p = ssl->handshake->premaster;

ssl_tls.c:7356

unsigned char *end = p + sizeof(ssl->handshake->premaster);

ssl_tls.c:7357

if ((ret = mbedtls_ecdh_calc_secret(&ssl->handshake->ecdh_ctx, &zlen,

ssl_tls.c:7438

ssl->handshake->pmslen = (size_t) (p - ssl->handshake->premaster);

ssl_tls.c:7472

mbedtls_ssl_write_certificate()

ssl->handshake->ciphersuite_info;

ssl_tls.c:7555

if (ssl->handshake->client_auth == 0) {

ssl_tls.c:7567

mbedtls_ssl_write_certificate()

ssl->handshake->ciphersuite_info;

ssl_tls.c:7870

ssl_parse_certificate_coordinate()

const int authmode = ssl->handshake->sni_authmode != MBEDTLS_SSL_VERIFY_UNSET

ssl_tls.c:7953

? ssl->handshake->sni_authmode

ssl_tls.c:7954

ssl->handshake->ciphersuite_info,

ssl_tls.c:8032

ssl_calc_finished_tls_generic()

ssl->handshake->tls_prf(session->master, 48, sender,

ssl_tls.c:8165

&ssl->handshake->fin_sha256,

ssl_tls.c:8193

ssl_calc_finished_tls_sha256()

&ssl->handshake->fin_sha384,

ssl_tls.c:8210

ssl_calc_finished_tls_sha384()

mbedtls_free(ssl->handshake);

ssl_tls.c:8225

ssl->handshake = NULL;

ssl_tls.c:8226

mbedtls_ssl_handshake_wrapup()

int resume = ssl->handshake->resume;

ssl_tls.c:8243

ssl->handshake->flight != NULL) {

ssl_tls.c:8286

mbedtls_ssl_handshake_wrapup()

ret = ssl->handshake->calc_finished(ssl, ssl->out_msg + 4, ssl->conf->endpoint);

ssl_tls.c:8311

if (ssl->handshake->resume != 0) {

ssl_tls.c:8337

ssl->handshake->alt_transform_out = ssl->transform_out;

ssl_tls.c:8363

memcpy(ssl->handshake->alt_out_ctr, ssl->cur_out_ctr,

ssl_tls.c:8364

sizeof(ssl->handshake->alt_out_ctr));

ssl_tls.c:8365

mbedtls_ssl_parse_finished()

ret = ssl->handshake->calc_finished(ssl, buf, ssl->conf->endpoint ^ 1);

ssl_tls.c:8424

if (ssl->handshake->resume != 0) {

ssl_tls.c:8471

mbedtls_ssl_parse_finished()

if ((ret = mbedtls_md_update(&ctx, ssl->handshake->randbytes, 64)) != 0) {

ssl_tls.c:9189

mbedtls_ssl_get_key_exchange_md_tls1_2()

uint16_t *received_sig_algs = ssl->handshake->received_sig_algs;

ssl_tls.c:9222

mbedtls_ssl_tls12_get_preferred_hash_for_sig_alg()

mbedtls_ecjpake_check(&ssl->handshake->ecjpake_ctx) != 0)

ssl_tls.c:9300

mbedtls_ssl_validate_ciphersuite()

ssl->handshake->sni_name = p + 3;

ssl_tls.c:9476

mbedtls_ssl_parse_server_name_ext()

ssl->handshake->sni_name_len = hostname_len;

ssl_tls.c:9477

mbedtls_ssl_parse_server_name_ext()

if (ssl->handshake->sni_ca_chain != NULL) {

ssl_tls.c:9834

ca_chain = ssl->handshake->sni_ca_chain;

ssl_tls.c:9835

ca_crl = ssl->handshake->sni_ca_crl;

ssl_tls.c:9836

if (mbedtls_ecjpake_check(&ssl->handshake->ecjpake_ctx) != 0) {

ssl_tls12_client.c:145

if (ssl->handshake->ecjpake_cache == NULL ||

ssl_tls12_client.c:163

ssl->handshake->ecjpake_cache_len == 0) {

ssl_tls12_client.c:164

ret = mbedtls_ecjpake_write_round_one(&ssl->handshake->ecjpake_ctx,

ssl_tls12_client.c:178

ssl->handshake->ecjpake_cache = mbedtls_calloc(1, kkpp_len);

ssl_tls12_client.c:188

if (ssl->handshake->ecjpake_cache == NULL) {

ssl_tls12_client.c:189

memcpy(ssl->handshake->ecjpake_cache, p + 2, kkpp_len);

ssl_tls12_client.c:194

ssl->handshake->ecjpake_cache_len = kkpp_len;

ssl_tls12_client.c:195

kkpp_len = ssl->handshake->ecjpake_cache_len;

ssl_tls12_client.c:199

memcpy(p + 2, ssl->handshake->ecjpake_cache, kkpp_len);

ssl_tls12_client.c:202

ssl->handshake->extended_ms = MBEDTLS_SSL_EXTENDED_MS_ENABLED;

ssl_tls12_client.c:779

ssl->handshake->new_session_ticket = 1;

ssl_tls12_client.c:805

ssl_parse_supported_point_formats_ext()

ssl->handshake->ecdh_ctx.point_format = p[0];

ssl_tls12_client.c:836

mbedtls_ecjpake_set_point_format(&ssl->handshake->ecjpake_ctx,

ssl_tls12_client.c:840

ssl_parse_supported_point_formats_ext()

if (ssl->handshake->ciphersuite_info->key_exchange !=

ssl_tls12_client.c:868

mbedtls_free(ssl->handshake->ecjpake_cache);

ssl_tls12_client.c:875

ssl->handshake->ecjpake_cache = NULL;

ssl_tls12_client.c:876

ssl->handshake->ecjpake_cache_len = 0;

ssl_tls12_client.c:877

if ((ret = mbedtls_ecjpake_read_round_one(&ssl->handshake->ecjpake_ctx,

ssl_tls12_client.c:896

mbedtls_free(ssl->handshake->cookie);

ssl_tls12_client.c:1154

ssl->handshake->cookie = mbedtls_calloc(1, cookie_len);

ssl_tls12_client.c:1156

if (ssl->handshake->cookie == NULL) {

ssl_tls12_client.c:1157

memcpy(ssl->handshake->cookie, p, cookie_len);

ssl_tls12_client.c:1162

ssl->handshake->cookie_len = cookie_len;

ssl_tls12_client.c:1163

mbedtls_free(ssl->handshake->cookie);

ssl_tls12_client.c:1241

ssl->handshake->cookie = NULL;

ssl_tls12_client.c:1242

ssl->handshake->cookie_len = 0;

ssl_tls12_client.c:1243

memcpy(ssl->handshake->randbytes + 32, buf + 2, 32);

ssl_tls12_client.c:1296

ssl->handshake->ciphersuite_info = mbedtls_ssl_ciphersuite_from_id(i);

ssl_tls12_client.c:1351

if (ssl->handshake->ciphersuite_info == NULL) {

ssl_tls12_client.c:1352

mbedtls_ssl_optimize_checksum(ssl, ssl->handshake->ciphersuite_info);

ssl_tls12_client.c:1360

if (ssl->handshake->resume == 0 || n == 0 ||

ssl_tls12_client.c:1368

ssl->handshake->resume = 0;

ssl_tls12_client.c:1376

if (ssl->handshake->resume) {

ssl_tls12_client.c:1610

ssl_parse_server_dh_params()

if ((ret = mbedtls_dhm_read_params(&ssl->handshake->dhm_ctx,

ssl_tls12_client.c:1685

dhm_actual_bitlen = mbedtls_dhm_get_bitlen(&ssl->handshake->dhm_ctx);

ssl_tls12_client.c:1691

ssl_parse_server_dh_params()

grp_id = ssl->handshake->ecdh_ctx.grp_id;

ssl_tls12_client.c:1796

ssl_check_server_ecdh_params()

if ((ret = mbedtls_ecdh_read_params(&ssl->handshake->ecdh_ctx,

ssl_tls12_client.c:1842

ssl_parse_server_ecdh_params()

unsigned char *p = ssl->handshake->premaster + pms_offset;

ssl_tls12_client.c:1918

ssl->handshake->pmslen = 48;

ssl_tls12_client.c:1941

p, ssl->handshake->pmslen,

ssl_tls12_client.c:1963

if ((ret = mbedtls_ecdh_get_params(&ssl->handshake->ecdh_ctx, peer_key,

ssl_tls12_client.c:2058

ssl_parse_server_key_exchange()

ssl->handshake->ciphersuite_info;

ssl_tls12_client.c:2086

ret = mbedtls_ecjpake_read_round_two(&ssl->handshake->ecjpake_ctx,

ssl_tls12_client.c:2275

ssl_parse_server_key_exchange()

ssl->handshake->ciphersuite_info;

ssl_tls12_client.c:2491

ssl->handshake->client_auth =

ssl_tls12_client.c:2521

if (ssl->handshake->client_auth == 0) {

ssl_tls12_client.c:2527

ssl->handshake->ciphersuite_info;

ssl_tls12_client.c:2712

content_len = mbedtls_dhm_get_len(&ssl->handshake->dhm_ctx);

ssl_tls12_client.c:2721

ret = mbedtls_dhm_make_public(&ssl->handshake->dhm_ctx,

ssl_tls12_client.c:2726

(int) mbedtls_dhm_get_len(&ssl->handshake->dhm_ctx),

ssl_tls12_client.c:2727

if ((ret = mbedtls_dhm_calc_secret(&ssl->handshake->dhm_ctx,

ssl_tls12_client.c:2738

ssl->handshake->premaster,

ssl_tls12_client.c:2739

&ssl->handshake->pmslen,

ssl_tls12_client.c:2741

ret = mbedtls_ecdh_make_public(&ssl->handshake->ecdh_ctx,

ssl_tls12_client.c:2846

if ((ret = mbedtls_ecdh_calc_secret(&ssl->handshake->ecdh_ctx,

ssl_tls12_client.c:2874

&ssl->handshake->pmslen,

ssl_tls12_client.c:2875

ssl->handshake->premaster,

ssl_tls12_client.c:2876

ret = mbedtls_ecdh_make_public(&ssl->handshake->ecdh_ctx,

ssl_tls12_client.c:3115

ret = mbedtls_ecjpake_write_round_two(&ssl->handshake->ecjpake_ctx,

ssl_tls12_client.c:3172

ret = mbedtls_ecjpake_derive_secret(&ssl->handshake->ecjpake_ctx,

ssl_tls12_client.c:3182

ssl->handshake->premaster, 32, &ssl->handshake->pmslen,

ssl_tls12_client.c:3183

ssl->handshake->ciphersuite_info;

ssl_tls12_client.c:3244

if (ssl->handshake->client_auth == 0 ||

ssl_tls12_client.c:3277

ret = ssl->handshake->calc_verify(ssl, hash, &hashlen);

ssl_tls12_client.c:3300

if (ssl->handshake->ciphersuite_info->mac == MBEDTLS_MD_SHA384) {

ssl_tls12_client.c:3322

ssl_parse_new_session_ticket()

ssl->handshake->new_session_ticket = 0;

ssl_tls12_client.c:3435

ssl->handshake->new_session_ticket != 0) {

ssl_tls12_client.c:3496

mbedtls_ssl_handshake_client_step()

if (ssl->handshake->curves_tls_id != NULL) {

ssl_tls12_server.c:205

ssl_parse_supported_groups_ext()

ssl->handshake->curves_tls_id = curves_tls_id;

ssl_tls12_server.c:226

ssl_parse_supported_groups_ext()

ssl->handshake->ecdh_ctx.point_format = p[0];

ssl_tls12_server.c:267

ssl_parse_supported_point_formats()

mbedtls_ecjpake_set_point_format(&ssl->handshake->ecjpake_ctx,

ssl_tls12_server.c:271

ssl_parse_supported_point_formats()

if (mbedtls_ecjpake_check(&ssl->handshake->ecjpake_ctx) != 0)

ssl_tls12_server.c:299

if ((ret = mbedtls_ecjpake_read_round_one(&ssl->handshake->ecjpake_ctx,

ssl_tls12_server.c:322

ssl->handshake->cli_exts |= MBEDTLS_TLS_EXT_ECJPAKE_KKPP_OK;

ssl_tls12_server.c:332

ssl->handshake->extended_ms = MBEDTLS_SSL_EXTENDED_MS_ENABLED;

ssl_tls12_server.c:461

ssl->handshake->new_session_ticket = 1;

ssl_tls12_server.c:485

ssl->handshake->resume = 1;

ssl_tls12_server.c:533

ssl->handshake->new_session_ticket = 0;

ssl_tls12_server.c:536

if (ssl->handshake->sni_key_cert != NULL) {

ssl_tls12_server.c:703

list = ssl->handshake->sni_key_cert;

ssl_tls12_server.c:704

ssl->handshake->curves_tls_id) != 0) {

ssl_tls12_server.c:770

ssl->handshake->key_cert = cur;

ssl_tls12_server.c:782

(ssl->handshake->cli_exts & MBEDTLS_TLS_EXT_ECJPAKE_KKPP_OK) == 0) {

ssl_tls12_server.c:823

(ssl->handshake->curves_tls_id == NULL ||

ssl_tls12_server.c:834

ssl->handshake->curves_tls_id[0] == 0)) {

ssl_tls12_server.c:835

ret = ssl->handshake->update_checksum(ssl, buf, msg_len);

ssl_tls12_server.c:1035

if (cli_msg_seq != ssl->handshake->in_msg_seq) {

ssl_tls12_server.c:1093

ssl->handshake->in_msg_seq++;

ssl_tls12_server.c:1100

ssl->handshake->out_msg_seq = cli_msg_seq;

ssl_tls12_server.c:1105

ssl->handshake->in_msg_seq = cli_msg_seq + 1;

ssl_tls12_server.c:1106

memcpy(ssl->handshake->randbytes, buf + 2, 32);

ssl_tls12_server.c:1180

ssl->handshake->cookie_verify_result = 1;

ssl_tls12_server.c:1231

ssl->handshake->cookie_verify_result = 0;

ssl_tls12_server.c:1234

ssl->handshake->cli_exts |= MBEDTLS_TLS_EXT_SUPPORTED_POINT_FORMATS_PRESENT;

ssl_tls12_server.c:1389

uint16_t *received_sig_algs = ssl->handshake->received_sig_algs;

ssl_tls12_server.c:1505

ssl->handshake->sni_name = NULL;

ssl_tls12_server.c:1588

ssl->handshake->sni_name_len = 0;

ssl_tls12_server.c:1589

ssl->handshake->ciphersuite_info = ciphersuite_info;

ssl_tls12_server.c:1659

ssl_write_extended_ms_ext()

if (ssl->handshake->extended_ms == MBEDTLS_SSL_EXTENDED_MS_DISABLED) {

ssl_tls12_server.c:1786

if (ssl->handshake->new_session_ticket == 0) {

ssl_tls12_server.c:1811

ssl_write_session_ticket_ext()

if ((ssl->handshake->cli_exts &

ssl_tls12_server.c:1901

ssl_write_supported_point_formats_ext()

if (ssl->handshake->ciphersuite_info->key_exchange !=

ssl_tls12_server.c:1937

ret = mbedtls_ecjpake_write_round_one(&ssl->handshake->ecjpake_ctx,

ssl_tls12_server.c:1963

ssl_handle_id_based_session_resumption()

if (ssl->handshake->resume == 1) {

ssl_tls12_server.c:2118

ssl->handshake->resume = 1;

ssl_tls12_server.c:2154

ssl_handle_id_based_session_resumption()

ssl->handshake->cookie_verify_result != 0) {

ssl_tls12_server.c:2175

memcpy(ssl->handshake->randbytes + 32, buf + 6, 32);

ssl_tls12_server.c:2246

if (ssl->handshake->resume == 0) {

ssl_tls12_server.c:2252

if (ssl->handshake->new_session_ticket != 0) {

ssl_tls12_server.c:2264

ssl->handshake->ciphersuite_info;

ssl_tls12_server.c:2420

if (ssl->handshake->sni_authmode != MBEDTLS_SSL_VERIFY_UNSET) {

ssl_tls12_server.c:2433

authmode = ssl->handshake->sni_authmode;

ssl_tls12_server.c:2434

if (ssl->handshake->dn_hints != NULL) {

ssl_tls12_server.c:2537

crt = ssl->handshake->dn_hints;

ssl_tls12_server.c:2538

if (ssl->handshake->sni_ca_chain != NULL) {

ssl_tls12_server.c:2546

crt = ssl->handshake->sni_ca_chain;

ssl_tls12_server.c:2547

if ((ret = mbedtls_ecdh_get_params(&ssl->handshake->ecdh_ctx,

ssl_tls12_server.c:2753

ssl->handshake->ciphersuite_info;

ssl_tls12_server.c:2800

&ssl->handshake->ecjpake_ctx,

ssl_tls12_server.c:2876

if ((ret = mbedtls_dhm_set_group(&ssl->handshake->dhm_ctx,

ssl_tls12_server.c:2927

&ssl->handshake->dhm_ctx,

ssl_tls12_server.c:2935

(int) mbedtls_dhm_get_len(&ssl->handshake->dhm_ctx),

ssl_tls12_server.c:2936

uint16_t *curr_tls_id = ssl->handshake->curves_tls_id;

ssl_tls12_server.c:2969

for (curr_tls_id = ssl->handshake->curves_tls_id;

ssl_tls12_server.c:2979

if ((ret = mbedtls_ecdh_setup(&ssl->handshake->ecdh_ctx,

ssl_tls12_server.c:3082

&ssl->handshake->ecdh_ctx, &len,

ssl_tls12_server.c:3089

ssl_write_server_key_exchange()

ssl->handshake->ciphersuite_info;

ssl_tls12_server.c:3253

if ((ret = mbedtls_dhm_read_public(&ssl->handshake->dhm_ctx, *p, n)) != 0) {

ssl_tls12_server.c:3404

ssl_parse_client_dh_public()

unsigned char *pms = ssl->handshake->premaster + pms_offset;

ssl_tls12_server.c:3532

if (sizeof(ssl->handshake->premaster) < pms_offset ||

ssl_tls12_server.c:3592

sizeof(ssl->handshake->premaster) - pms_offset < 48) {

ssl_tls12_server.c:3593

ssl->handshake->pmslen = 48;

ssl_tls12_server.c:3597

mbedtls_ct_memcpy_if(diff, pms, fake_pms, peer_pms, ssl->handshake->pmslen);

ssl_tls12_server.c:3601

ciphersuite_info = ssl->handshake->ciphersuite_info;

ssl_tls12_server.c:3670

if ((ret = mbedtls_dhm_calc_secret(&ssl->handshake->dhm_ctx,

ssl_tls12_server.c:3716

ssl->handshake->premaster,

ssl_tls12_server.c:3717

&ssl->handshake->pmslen,

ssl_tls12_server.c:3719

if ((ret = mbedtls_ecdh_read_public(&ssl->handshake->ecdh_ctx,

ssl_tls12_server.c:3798

if ((ret = mbedtls_ecdh_calc_secret(&ssl->handshake->ecdh_ctx,

ssl_tls12_server.c:3807

&ssl->handshake->pmslen,

ssl_tls12_server.c:3808

ssl->handshake->premaster,

ssl_tls12_server.c:3809

if ((ret = mbedtls_ecdh_read_public(&ssl->handshake->ecdh_ctx,

ssl_tls12_server.c:4011

ret = mbedtls_ecjpake_read_round_two(&ssl->handshake->ecjpake_ctx,

ssl_tls12_server.c:4050

ret = mbedtls_ecjpake_derive_secret(&ssl->handshake->ecjpake_ctx,

ssl_tls12_server.c:4057

ssl->handshake->premaster, 32, &ssl->handshake->pmslen,

ssl_tls12_server.c:4058

ssl_parse_certificate_verify()

ssl->handshake->ciphersuite_info;

ssl_tls12_server.c:4114

ret = ssl->handshake->calc_verify(ssl, hash, &dummy_hlen);

ssl_tls12_server.c:4236

ssl_parse_certificate_verify()

ssl->handshake->new_session_ticket = 0;

ssl_tls12_server.c:4306

ssl_write_new_session_ticket()

if (ssl->handshake->new_session_ticket != 0) {

ssl_tls12_server.c:4406

mbedtls_ssl_handshake_server_step()

Call Tree

from 0/1 examples

All items filtered out

Data Use

from 0/1 examples

mbedtls_ssl_context::handshake is written by 2 functions and is read by 117 functions:

mbedtls_ssl_context::handshake

ssl_write_client_hello_cipher_suites()

mbedtls_ssl_own_key()

mbedtls_ssl_own_cert()

ssl_write_client_hello_body()

ssl_generate_random()

mbedtls_ssl_write_client_hello()

ssl_reset_retransmit_timeout()

mbedtls_ssl_fetch_input()

ssl_load_buffered_message()

ssl_buffer_make_space()

ssl_free_buffered_record()

ssl_load_buffered_record()

ssl_buffer_future_record()

mbedtls_ssl_handle_message_type()

mbedtls_ssl_read()

mbedtls_ssl_buffering_free()

ssl_buffering_free_slot()

mbedtls_ssl_optimize_checksum()

mbedtls_ssl_add_hs_hdr_to_checksum()

mbedtls_ssl_add_hs_msg_to_checksum()

ssl_update_checksum_start()

ssl_update_checksum_sha256()

ssl_update_checksum_sha384()

mbedtls_ssl_set_session()

mbedtls_ssl_get_hs_sni()

mbedtls_ssl_set_hs_own_cert()

mbedtls_ssl_set_hs_ca_chain()

mbedtls_ssl_set_hs_dn_hints()

mbedtls_ssl_set_hs_authmode()

mbedtls_ssl_set_hs_ecjpake_password()

ssl_prepare_handshake_step()

mbedtls_ssl_handshake_step()

mbedtls_ssl_start_renegotiation()

mbedtls_ssl_handshake_free()

mbedtls_ssl_free()

ssl_get_handshake_transcript_sha384()

ssl_get_handshake_transcript_sha256()

mbedtls_ssl_set_calc_verify_md()

ssl_calc_verify_tls_sha256()

ssl_calc_verify_tls_sha384()

mbedtls_ssl_write_certificate()

ssl_parse_certificate_coordinate()

ssl_calc_finished_tls_generic()

ssl_calc_finished_tls_sha256()

ssl_calc_finished_tls_sha384()

mbedtls_ssl_handshake_wrapup()

mbedtls_ssl_parse_finished()

mbedtls_ssl_get_key_exchange_md_tls1_2()

mbedtls_ssl_tls12_get_preferred_hash_for_sig_alg()

mbedtls_ssl_validate_ciphersuite()

mbedtls_ssl_parse_server_name_ext()

ssl_parse_supported_point_formats_ext()

ssl_parse_server_dh_params()

ssl_check_server_ecdh_params()

ssl_parse_server_ecdh_params()

ssl_parse_server_key_exchange()

ssl_parse_new_session_ticket()

mbedtls_ssl_handshake_client_step()

ssl_parse_supported_groups_ext()

ssl_parse_supported_point_formats()

ssl_write_extended_ms_ext()

ssl_write_session_ticket_ext()

ssl_write_supported_point_formats_ext()

ssl_handle_id_based_session_resumption()

ssl_write_server_key_exchange()

ssl_parse_client_dh_public()