Lines Matching defs:ret
294 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
307 if ((ret = mbedtls_psa_ecjpake_read_round(
313 MBEDTLS_SSL_DEBUG_RET(1, "psa_pake_input round one", ret);
319 return ret;
322 if ((ret = mbedtls_ecjpake_read_round_one(&ssl->handshake->ecjpake_ctx,
324 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecjpake_read_round_one", ret);
327 return ret;
474 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
503 if ((ret = ssl->conf->f_ticket_parse(ssl->conf->p_ticket, &session,
507 if (ret == MBEDTLS_ERR_SSL_INVALID_MAC) {
509 } else if (ret == MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED) {
512 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_ticket_parse", ret);
889 int ret, got_common_suite;
931 if ((ret = mbedtls_ssl_fetch_input(ssl, 5)) != 0) {
933 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_fetch_input", ret);
934 return ret;
1013 if ((ret = mbedtls_ssl_fetch_input(ssl,
1015 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_fetch_input", ret);
1016 return ret;
1033 ret = ssl->handshake->update_checksum(ssl, buf, msg_len);
1034 if (0 != ret) {
1035 MBEDTLS_SSL_DEBUG_RET(1, ("update_checksum"), ret);
1036 return ret;
1340 ret = mbedtls_ssl_parse_server_name_ext(ssl, ext + 4,
1342 if (ret != 0) {
1343 return ret;
1354 ret = ssl_parse_renegotiation_info(ssl, ext + 4, ext_size);
1355 if (ret != 0) {
1356 return ret;
1364 ret = mbedtls_ssl_parse_sig_alg_ext(ssl, ext + 4, ext + 4 + ext_size);
1365 if (ret != 0) {
1366 return ret;
1379 ret = ssl_parse_supported_groups_ext(ssl, ext + 4, ext_size);
1380 if (ret != 0) {
1381 return ret;
1389 ret = ssl_parse_supported_point_formats(ssl, ext + 4, ext_size);
1390 if (ret != 0) {
1391 return ret;
1402 ret = ssl_parse_ecjpake_kkpp(ssl, ext + 4, ext_size);
1403 if (ret != 0) {
1404 return ret;
1413 ret = ssl_parse_max_fragment_length_ext(ssl, ext + 4, ext_size);
1414 if (ret != 0) {
1415 return ret;
1424 ret = ssl_parse_cid_ext(ssl, ext + 4, ext_size);
1425 if (ret != 0) {
1426 return ret;
1435 ret = ssl_parse_encrypt_then_mac_ext(ssl, ext + 4, ext_size);
1436 if (ret != 0) {
1437 return ret;
1446 ret = ssl_parse_extended_ms_ext(ssl, ext + 4, ext_size);
1447 if (ret != 0) {
1448 return ret;
1457 ret = ssl_parse_session_ticket_ext(ssl, ext + 4, ext_size);
1458 if (ret != 0) {
1459 return ret;
1468 ret = mbedtls_ssl_parse_alpn_ext(ssl, ext + 4,
1470 if (ret != 0) {
1471 return ret;
1480 ret = ssl_parse_use_srtp_ext(ssl, ext + 4, ext_size);
1481 if (ret != 0) {
1482 return ret;
1581 if (ssl->conf->f_cert_cb && (ret = ssl->conf->f_cert_cb(ssl)) != 0) {
1582 MBEDTLS_SSL_DEBUG_RET(1, "f_cert_cb", ret);
1583 return ret;
1609 if ((ret = ssl_ciphersuite_match(ssl, ciphersuites[i],
1611 return ret;
1628 if ((ret = ssl_ciphersuite_match(ssl, ciphersuites[i],
1630 return ret;
1927 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1951 ret = mbedtls_psa_ecjpake_write_round(&ssl->handshake->psa_pake_ctx,
1954 if (ret != 0) {
1957 MBEDTLS_SSL_DEBUG_RET(1, "psa_pake_output", ret);
1961 ret = mbedtls_ecjpake_write_round_one(&ssl->handshake->ecjpake_ctx,
1964 if (ret != 0) {
1965 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecjpake_write_round_one", ret);
2044 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2072 if ((ret = ssl->conf->f_cookie_write(ssl->conf->p_cookie,
2075 MBEDTLS_SSL_DEBUG_RET(1, "f_cookie_write", ret);
2076 return ret;
2089 if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
2090 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
2091 return ret;
2096 (ret = mbedtls_ssl_flight_transmit(ssl)) != 0) {
2097 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_flight_transmit", ret);
2098 return ret;
2110 int ret;
2133 ret = ssl->conf->f_get_cache(ssl->conf->p_cache,
2137 if (ret != 0) {
2165 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2205 if ((ret = ssl->conf->f_rng(ssl->conf->p_rng, p, 4)) != 0) {
2206 return ret;
2212 if ((ret = ssl->conf->f_rng(ssl->conf->p_rng, p, 20)) != 0) {
2213 return ret;
2238 if ((ret = ssl->conf->f_rng(ssl->conf->p_rng, p, 8)) != 0) {
2239 return ret;
2269 if ((ret = ssl->conf->f_rng(ssl->conf->p_rng, ssl->session_negotiate->id,
2271 return ret;
2281 if ((ret = mbedtls_ssl_derive_keys(ssl)) != 0) {
2282 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_derive_keys", ret);
2283 return ret;
2362 if ((ret = mbedtls_ssl_write_alpn_ext(ssl, p + 2 + ext_len, end, &olen))
2364 return ret;
2387 ret = mbedtls_ssl_write_handshake_msg(ssl);
2391 return ret;
2416 int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
2577 ret = mbedtls_ssl_write_handshake_msg(ssl);
2581 return ret;
2591 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2628 ret = PSA_TO_MBEDTLS_ERR(status);
2655 ret = PSA_TO_MBEDTLS_ERR(status);
2661 ret = PSA_TO_MBEDTLS_ERR(status);
2670 ret = 0;
2701 ret = mbedtls_ecp_write_key_ext(key, &key_len, buf, sizeof(buf));
2702 if (ret != 0) {
2710 ret = PSA_TO_MBEDTLS_ERR(status);
2716 ret = 0;
2720 ret = MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH;
2727 return ret;
2733 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2746 if ((ret = mbedtls_ecdh_get_params(&ssl->handshake->ecdh_ctx,
2749 MBEDTLS_SSL_DEBUG_RET(1, ("mbedtls_ecdh_get_params"), ret);
2750 return ret;
2773 int ret = ssl->conf->f_async_resume(ssl,
2775 if (ret != MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS) {
2779 MBEDTLS_SSL_DEBUG_RET(2, "ssl_resume_server_key_exchange", ret);
2780 return ret;
2827 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2852 ret = mbedtls_psa_ecjpake_write_round(&ssl->handshake->psa_pake_ctx,
2856 if (ret != 0) {
2859 MBEDTLS_SSL_DEBUG_RET(1, "psa_pake_output", ret);
2860 return ret;
2868 ret = mbedtls_ecjpake_write_round_two(
2873 if (ret != 0) {
2874 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecjpake_write_round_two", ret);
2875 return ret;
2903 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2920 if ((ret = mbedtls_dhm_set_group(&ssl->handshake->dhm_ctx,
2923 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_dhm_set_group", ret);
2924 return ret;
2927 if ((ret = mbedtls_dhm_make_params(
2932 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_dhm_make_params", ret);
2933 return ret;
2964 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3035 ret = PSA_TO_MBEDTLS_ERR(status);
3036 MBEDTLS_SSL_DEBUG_RET(1, "psa_generate_key", ret);
3037 return ret;
3059 ret = PSA_TO_MBEDTLS_ERR(status);
3060 MBEDTLS_SSL_DEBUG_RET(1, "psa_export_public_key", ret);
3063 return ret;
3075 if ((ret = mbedtls_ecdh_setup(&ssl->handshake->ecdh_ctx,
3077 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecp_group_load", ret);
3078 return ret;
3081 if ((ret = mbedtls_ecdh_make_params(
3086 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecdh_make_params", ret);
3087 return ret;
3119 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3151 ret = mbedtls_ssl_get_key_exchange_md_tls1_2(ssl, hash, &hashlen,
3155 if (ret != 0) {
3156 return ret;
3189 ret = ssl->conf->f_async_sign_start(ssl,
3192 switch (ret) {
3203 MBEDTLS_SSL_DEBUG_RET(1, "f_async_sign_start", ret);
3204 return ret;
3219 if ((ret = mbedtls_pk_sign(mbedtls_ssl_own_key(ssl),
3226 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_pk_sign", ret);
3227 return ret;
3242 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3259 ret = ssl_get_ecdh_params_from_cert(ssl);
3260 if (ret != 0) {
3261 MBEDTLS_SSL_DEBUG_RET(1, "ssl_get_ecdh_params_from_cert", ret);
3262 return ret;
3281 ret = ssl_resume_server_key_exchange(ssl, &signature_len);
3287 ret = ssl_prepare_server_key_exchange(ssl, &signature_len);
3290 if (ret != 0) {
3295 if (ret == MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS) {
3300 return ret;
3326 if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
3327 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
3328 return ret;
3338 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3354 if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
3355 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
3356 return ret;
3361 (ret = mbedtls_ssl_flight_transmit(ssl)) != 0) {
3362 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_flight_transmit", ret);
3363 return ret;
3378 int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
3397 if ((ret = mbedtls_dhm_read_public(&ssl->handshake->dhm_ctx, *p, n)) != 0) {
3398 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_dhm_read_public", ret);
3406 return ret;
3421 int ret = ssl->conf->f_async_resume(ssl,
3423 if (ret != MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS) {
3427 MBEDTLS_SSL_DEBUG_RET(2, "ssl_decrypt_encrypted_pms", ret);
3428 return ret;
3440 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3484 ret = ssl->conf->f_async_decrypt_start(ssl,
3487 switch (ret) {
3501 MBEDTLS_SSL_DEBUG_RET(1, "f_async_decrypt_start", ret);
3502 return ret;
3512 ret = mbedtls_pk_decrypt(private_key, p, len,
3515 return ret;
3524 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3534 * ret being nonzero, and we only care whether diff is 0.
3541 ret = ssl_decrypt_encrypted_pms(ssl, p, end,
3547 if (ret == MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS) {
3548 return ret;
3558 diff = mbedtls_ct_bool(ret);
3572 ret = ssl->conf->f_rng(ssl->conf->p_rng, fake_pms, sizeof(fake_pms));
3573 if (ret != 0) {
3576 return ret;
3606 int ret = 0;
3632 ret = MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY;
3639 ret = MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY;
3643 if (ret == MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY) {
3659 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3679 if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) {
3680 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_read_record", ret);
3681 return ret;
3699 if ((ret = ssl_parse_client_dh_public(ssl, &p, end)) != 0) {
3700 MBEDTLS_SSL_DEBUG_RET(1, ("ssl_parse_client_dh_public"), ret);
3701 return ret;
3709 if ((ret = mbedtls_dhm_calc_secret(&ssl->handshake->dhm_ctx,
3714 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_dhm_calc_secret", ret);
3771 ret = PSA_TO_MBEDTLS_ERR(status);
3772 MBEDTLS_SSL_DEBUG_RET(1, "psa_raw_key_agreement", ret);
3777 return ret;
3784 ret = PSA_TO_MBEDTLS_ERR(status);
3785 MBEDTLS_SSL_DEBUG_RET(1, "psa_destroy_key", ret);
3786 return ret;
3791 if ((ret = mbedtls_ecdh_read_public(&ssl->handshake->ecdh_ctx,
3793 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecdh_read_public", ret);
3800 if ((ret = mbedtls_ecdh_calc_secret(&ssl->handshake->ecdh_ctx,
3805 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecdh_calc_secret", ret);
3819 if ((ret = ssl_parse_client_psk_identity(ssl, &p, end)) != 0) {
3820 MBEDTLS_SSL_DEBUG_RET(1, ("ssl_parse_client_psk_identity"), ret);
3821 return ret;
3830 if ((ret = mbedtls_ssl_psk_derive_premaster(ssl,
3833 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_psk_derive_premaster", ret);
3834 return ret;
3852 if ((ret = ssl_parse_client_psk_identity(ssl, &p, end)) != 0) {
3853 MBEDTLS_SSL_DEBUG_RET(1, ("ssl_parse_client_psk_identity"), ret);
3854 return ret;
3857 if ((ret = ssl_parse_encrypted_pms(ssl, p, end, 2)) != 0) {
3858 MBEDTLS_SSL_DEBUG_RET(1, ("ssl_parse_encrypted_pms"), ret);
3859 return ret;
3863 if ((ret = mbedtls_ssl_psk_derive_premaster(ssl,
3866 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_psk_derive_premaster", ret);
3867 return ret;
3874 if ((ret = ssl_parse_client_psk_identity(ssl, &p, end)) != 0) {
3875 MBEDTLS_SSL_DEBUG_RET(1, ("ssl_parse_client_psk_identity"), ret);
3876 return ret;
3878 if ((ret = ssl_parse_client_dh_public(ssl, &p, end)) != 0) {
3879 MBEDTLS_SSL_DEBUG_RET(1, ("ssl_parse_client_dh_public"), ret);
3880 return ret;
3894 if ((ret = mbedtls_dhm_calc_secret(&ssl->handshake->dhm_ctx,
3897 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_dhm_calc_secret", ret);
3898 return ret;
3905 if ((ret = mbedtls_ssl_psk_derive_premaster(ssl,
3908 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_psk_derive_premaster", ret);
3909 return ret;
3923 if ((ret = ssl_parse_client_psk_identity(ssl, &p, end)) != 0) {
3924 MBEDTLS_SSL_DEBUG_RET(1, ("ssl_parse_client_psk_identity"), ret);
3927 return ret;
3999 if ((ret = ssl_parse_client_psk_identity(ssl, &p, end)) != 0) {
4000 MBEDTLS_SSL_DEBUG_RET(1, ("ssl_parse_client_psk_identity"), ret);
4001 return ret;
4004 if ((ret = mbedtls_ecdh_read_public(&ssl->handshake->ecdh_ctx,
4006 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecdh_read_public", ret);
4013 if ((ret = mbedtls_ssl_psk_derive_premaster(ssl,
4016 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_psk_derive_premaster", ret);
4017 return ret;
4024 if ((ret = ssl_parse_encrypted_pms(ssl, p, end, 0)) != 0) {
4025 MBEDTLS_SSL_DEBUG_RET(1, ("ssl_parse_parse_encrypted_pms_secret"), ret);
4026 return ret;
4033 if ((ret = mbedtls_psa_ecjpake_read_round(
4039 MBEDTLS_SSL_DEBUG_RET(1, "psa_pake_input round two", ret);
4040 return ret;
4043 ret = mbedtls_ecjpake_read_round_two(&ssl->handshake->ecjpake_ctx,
4045 if (ret != 0) {
4046 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecjpake_read_round_two", ret);
4050 ret = mbedtls_ecjpake_derive_secret(&ssl->handshake->ecjpake_ctx,
4053 if (ret != 0) {
4054 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecjpake_derive_secret", ret);
4055 return ret;
4065 if ((ret = mbedtls_ssl_derive_keys(ssl)) != 0) {
4066 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_derive_keys", ret);
4067 return ret;
4099 int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
4133 ret = mbedtls_ssl_read_record(ssl, 0 /* no checksum update */);
4134 if (0 != ret) {
4135 MBEDTLS_SSL_DEBUG_RET(1, ("mbedtls_ssl_read_record"), ret);
4136 return ret;
4229 ret = ssl->handshake->calc_verify(ssl, hash, &dummy_hlen);
4230 if (0 != ret) {
4231 MBEDTLS_SSL_DEBUG_RET(1, ("calc_verify"), ret);
4232 return ret;
4236 if ((ret = mbedtls_pk_verify(peer_pk,
4239 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_pk_verify", ret);
4240 return ret;
4243 ret = mbedtls_ssl_update_handshake_status(ssl);
4244 if (0 != ret) {
4245 MBEDTLS_SSL_DEBUG_RET(1, ("mbedtls_ssl_update_handshake_status"), ret);
4246 return ret;
4251 return ret;
4259 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
4282 if ((ret = ssl->conf->f_ticket_write(ssl->conf->p_ticket,
4287 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_ticket_write", ret);
4301 if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
4302 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
4303 return ret;
4317 int ret = 0;
4330 ret = ssl_parse_client_hello(ssl);
4346 ret = ssl_write_server_hello(ssl);
4350 ret = mbedtls_ssl_write_certificate(ssl);
4354 ret = ssl_write_server_key_exchange(ssl);
4358 ret = ssl_write_certificate_request(ssl);
4362 ret = ssl_write_server_hello_done(ssl);
4373 ret = mbedtls_ssl_parse_certificate(ssl);
4377 ret = ssl_parse_client_key_exchange(ssl);
4381 ret = ssl_parse_certificate_verify(ssl);
4385 ret = mbedtls_ssl_parse_change_cipher_spec(ssl);
4389 ret = mbedtls_ssl_parse_finished(ssl);
4400 ret = ssl_write_new_session_ticket(ssl);
4403 ret = mbedtls_ssl_write_change_cipher_spec(ssl);
4407 ret = mbedtls_ssl_write_finished(ssl);
4424 return ret;