Lines Matching defs:ret
250 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
259 if ((ret = mbedtls_x509_crt_parse_der(dst->peer_cert, src->peer_cert->raw.p,
263 return ret;
286 int ret = mbedtls_ssl_session_set_ticket_alpn(dst, src->ticket_alpn);
287 if (ret != 0) {
288 return ret;
306 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
307 ret = mbedtls_ssl_session_set_hostname(dst, src->hostname);
308 if (ret != 0) {
309 return ret;
823 int ret;
824 ret = mbedtls_ssl_add_hs_hdr_to_checksum(ssl, hs_type, msg_len);
825 if (ret != 0) {
826 return ret;
838 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
856 ret = mbedtls_md_setup(&ssl->handshake->fin_sha256,
859 if (ret != 0) {
860 return ret;
862 ret = mbedtls_md_starts(&ssl->handshake->fin_sha256);
863 if (ret != 0) {
864 return ret;
881 ret = mbedtls_md_setup(&ssl->handshake->fin_sha384,
883 if (ret != 0) {
884 return ret;
886 ret = mbedtls_md_starts(&ssl->handshake->fin_sha384);
887 if (ret != 0) {
888 return ret;
903 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
917 ret = mbedtls_md_update(&ssl->handshake->fin_sha256, buf, len);
918 if (ret != 0) {
919 return ret;
930 ret = mbedtls_md_update(&ssl->handshake->fin_sha384, buf, len);
931 if (ret != 0) {
932 return ret;
1051 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1131 ret = mbedtls_ssl_reset_checksum(ssl);
1132 if (ret != 0) {
1133 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_reset_checksum", ret);
1134 return ret;
1351 int ret;
1352 ret = ssl_conf_version_check(ssl);
1353 if (ret != 0) {
1354 return ret;
1397 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1403 if ((ret = ssl_conf_check(ssl)) != 0) {
1404 return ret;
1421 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
1431 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
1441 if ((ret = ssl_handshake_init(ssl)) != 0) {
1472 return ret;
1566 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1608 if ((ret = ssl_handshake_init(ssl)) != 0) {
1609 return ret;
1748 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1776 if ((ret = mbedtls_ssl_session_copy(ssl->session_negotiate,
1778 return ret;
2187 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2212 ret = ssl_conf_set_psk_identity(conf, psk_identity, psk_identity_len);
2213 if (ret != 0) {
2217 return ret;
2310 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2324 ret = ssl_conf_set_psk_identity(conf, psk_identity,
2326 if (ret != 0) {
2330 return ret;
2672 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2677 if ((ret = mbedtls_mpi_read_binary(&conf->dhm_P, dhm_P, P_len)) != 0 ||
2678 (ret = mbedtls_mpi_read_binary(&conf->dhm_G, dhm_G, G_len)) != 0) {
2681 return ret;
2689 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2694 if ((ret = mbedtls_dhm_get_value(dhm_ctx, MBEDTLS_DHM_PARAM_P,
2696 (ret = mbedtls_dhm_get_value(dhm_ctx, MBEDTLS_DHM_PARAM_G,
2700 return ret;
3285 const int ret = mbedtls_ssl_get_record_expansion(ssl);
3286 const size_t overhead = (size_t) ret;
3288 if (ret < 0) {
3289 return ret;
3350 int ret;
3374 ret = mbedtls_ssl_session_copy(dst, ssl->session);
3375 if (ret != 0) {
3376 return ret;
3616 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3630 if ((ret = mbedtls_x509_crt_parse_der(session->peer_cert,
3635 return ret;
3967 int ret = mbedtls_ssl_session_set_ticket_alpn(session, (char *) p);
3968 if (ret != 0) {
3969 return ret;
4303 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
4346 ret = ssl_tls13_session_save(session, p, remaining_len, &out_len);
4347 if (ret != 0 && ret != MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL) {
4348 return ret;
4450 int ret = ssl_session_load(session, 0, buf, len);
4452 if (ret != 0) {
4456 return ret;
4465 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
4482 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) {
4483 return ret;
4489 if ((ret = mbedtls_ssl_flight_transmit(ssl)) != 0) {
4490 return ret;
4495 return ret;
4500 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
4509 ret = ssl_prepare_handshake_step(ssl);
4510 if (ret != 0) {
4511 return ret;
4514 ret = mbedtls_ssl_handle_pending_alert(ssl);
4515 if (ret != 0) {
4521 ret = MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
4531 ret = 0;
4535 ret = mbedtls_ssl_write_client_hello(ssl);
4541 ret = mbedtls_ssl_tls13_handshake_client_step(ssl);
4543 ret = mbedtls_ssl_handshake_client_step(ssl);
4546 ret = mbedtls_ssl_handshake_client_step(ssl);
4548 ret = mbedtls_ssl_tls13_handshake_client_step(ssl);
4558 ret = mbedtls_ssl_tls13_handshake_server_step(ssl);
4560 ret = mbedtls_ssl_handshake_server_step(ssl);
4563 ret = mbedtls_ssl_handshake_server_step(ssl);
4565 ret = mbedtls_ssl_tls13_handshake_server_step(ssl);
4570 if (ret != 0) {
4575 ret = mbedtls_ssl_handle_pending_alert(ssl);
4581 return ret;
4589 int ret = 0;
4610 ret = mbedtls_ssl_handshake_step(ssl);
4612 if (ret != 0) {
4619 return ret;
4630 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
4638 if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
4639 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
4640 return ret;
4660 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
4664 if ((ret = ssl_handshake_init(ssl)) != 0) {
4665 return ret;
4684 if ((ret = mbedtls_ssl_handshake(ssl)) != 0) {
4685 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_handshake", ret);
4686 return ret;
4700 int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
4734 if ((ret = mbedtls_ssl_start_renegotiation(ssl)) != 0) {
4735 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_start_renegotiation", ret);
4736 return ret;
4739 if ((ret = mbedtls_ssl_handshake(ssl)) != 0) {
4740 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_handshake", ret);
4741 return ret;
4746 return ret;
5042 int ret = 0;
5112 ret = ssl_session_save(ssl->session, 1, NULL, 0, &session_len);
5113 if (ret != MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL) {
5114 return ret;
5122 ret = ssl_session_save(ssl->session, 1,
5124 if (ret != 0) {
5125 return ret;
5241 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
5308 ret = ssl_session_load(ssl->session, 1, p, session_len);
5309 if (ret != 0) {
5311 return ret;
5340 ret = ssl_tls12_populate_transform(ssl->transform,
5351 if (ret != 0) {
5352 return ret;
5502 int ret = ssl_context_load(context, buf, len);
5504 if (ret != 0) {
5508 return ret;
5807 int ret = 0;
5817 ret = -1;
5820 return ret;
5832 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
5916 if ((ret = mbedtls_ssl_conf_dh_param_bin(conf,
5919 return ret;
6353 int ret = 0;
6392 ret = -1;
6405 ret = -1;
6408 return ret;
6468 int ret;
6476 ret = mbedtls_md_setup(&sha384, mbedtls_md_info_from_type(MBEDTLS_MD_SHA384), 0);
6477 if (ret != 0) {
6480 ret = mbedtls_md_clone(&sha384, &ssl->handshake->fin_sha384);
6481 if (ret != 0) {
6485 if ((ret = mbedtls_md_finish(&sha384, dst)) != 0) {
6486 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_finish", ret);
6495 return ret;
6506 int ret;
6514 ret = mbedtls_md_setup(&sha256, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 0);
6515 if (ret != 0) {
6518 ret = mbedtls_md_clone(&sha256, &ssl->handshake->fin_sha256);
6519 if (ret != 0) {
6523 if ((ret = mbedtls_md_finish(&sha256, dst)) != 0) {
6524 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_finish", ret);
6533 return ret;
6839 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
6852 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
6864 if ((ret = mbedtls_md_setup(&md_ctx, md_info, 1)) != 0) {
6868 ret = mbedtls_md_hmac_starts(&md_ctx, secret, slen);
6869 if (ret != 0) {
6872 ret = mbedtls_md_hmac_update(&md_ctx, tmp + md_len, nb);
6873 if (ret != 0) {
6876 ret = mbedtls_md_hmac_finish(&md_ctx, tmp);
6877 if (ret != 0) {
6882 ret = mbedtls_md_hmac_reset(&md_ctx);
6883 if (ret != 0) {
6886 ret = mbedtls_md_hmac_update(&md_ctx, tmp, md_len + nb);
6887 if (ret != 0) {
6890 ret = mbedtls_md_hmac_finish(&md_ctx, h_i);
6891 if (ret != 0) {
6895 ret = mbedtls_md_hmac_reset(&md_ctx);
6896 if (ret != 0) {
6899 ret = mbedtls_md_hmac_update(&md_ctx, tmp, md_len);
6900 if (ret != 0) {
6903 ret = mbedtls_md_hmac_finish(&md_ctx, tmp);
6904 if (ret != 0) {
6926 return ret;
7012 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
7055 ret = handshake->calc_verify(ssl, session_hash, &seed_len);
7056 if (ret != 0) {
7057 MBEDTLS_SSL_DEBUG_RET(1, "calc_verify", ret);
7180 ret = handshake->tls_prf(handshake->premaster, handshake->pmslen,
7184 if (ret != 0) {
7185 MBEDTLS_SSL_DEBUG_RET(1, "prf", ret);
7186 return ret;
7202 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
7209 ret = ssl_set_handshake_prfs(ssl->handshake,
7211 if (ret != 0) {
7212 MBEDTLS_SSL_DEBUG_RET(1, "ssl_set_handshake_prfs", ret);
7213 return ret;
7217 ret = ssl_compute_master(ssl->handshake,
7220 if (ret != 0) {
7221 MBEDTLS_SSL_DEBUG_RET(1, "ssl_compute_master", ret);
7222 return ret;
7237 ret = ssl_tls12_populate_transform(ssl->transform_negotiate,
7248 if (ret != 0) {
7249 MBEDTLS_SSL_DEBUG_RET(1, "ssl_tls12_populate_transform", ret);
7250 return ret;
7322 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
7332 ret = mbedtls_md_setup(&cloned_ctx, mbedtls_md_info_from_ctx(hs_ctx), 0);
7333 if (ret != 0) {
7336 ret = mbedtls_md_clone(&cloned_ctx, hs_ctx);
7337 if (ret != 0) {
7341 ret = mbedtls_md_finish(&cloned_ctx, hash);
7342 if (ret != 0) {
7353 return ret;
7452 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
7456 if ((ret = mbedtls_dhm_calc_secret(&ssl->handshake->dhm_ctx,
7459 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_dhm_calc_secret", ret);
7460 return ret;
7470 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
7473 if ((ret = mbedtls_ecdh_calc_secret(&ssl->handshake->ecdh_ctx, &zlen,
7476 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ecdh_calc_secret", ret);
7477 return ret;
7586 int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
7660 if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
7661 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
7662 return ret;
7667 return ret;
7696 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
7715 ret = mbedtls_md(digest_info, crt_buf, crt_buf_len, tmp_digest);
7716 if (ret != 0) {
7733 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
7837 ret = mbedtls_x509_crt_parse_der(chain, ssl->in_msg + i, n);
7841 ret = mbedtls_x509_crt_parse_der_nocopy(chain, ssl->in_msg + i, n);
7843 switch (ret) {
7862 MBEDTLS_SSL_DEBUG_RET(1, " mbedtls_x509_crt_parse_der", ret);
7863 return ret;
7936 int ret = 0;
7967 ret = mbedtls_x509_crt_verify_with_ca_cb(
7996 ret = mbedtls_x509_crt_verify_restartable(
8005 if (ret != 0) {
8006 MBEDTLS_SSL_DEBUG_RET(1, "x509_verify_cert", ret);
8010 if (ret == MBEDTLS_ERR_ECP_IN_PROGRESS) {
8016 * Secondary checks: always done, but change 'ret' only if it was 0
8040 if (ret == 0) {
8041 ret = MBEDTLS_ERR_SSL_BAD_CERTIFICATE;
8053 if (ret == 0) {
8054 ret = MBEDTLS_ERR_SSL_BAD_CERTIFICATE;
8065 (ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED ||
8066 ret == MBEDTLS_ERR_SSL_BAD_CERTIFICATE)) {
8067 ret = 0;
8072 ret = MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED;
8075 if (ret != 0) {
8117 return ret;
8125 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
8139 ret = mbedtls_md(mbedtls_md_info_from_type(
8149 return ret;
8157 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
8161 ret = mbedtls_pk_parse_subpubkey(&start, end,
8163 if (ret != 0) {
8174 int ret = 0;
8203 if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) {
8206 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_read_record", ret);
8215 ret = MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE;
8234 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
8239 ret = ssl_parse_certificate_chain(ssl, chain);
8240 if (ret != 0) {
8255 ret = ssl_parse_certificate_verify(ssl, authmode,
8257 if (ret != 0) {
8283 ret = ssl_remember_peer_crt_digest(ssl, crt_start, crt_len);
8284 if (ret != 0) {
8288 ret = ssl_remember_peer_pubkey(ssl, pk_start, pk_len);
8289 if (ret != 0) {
8303 if (ret == 0) {
8308 if (ret == MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS) {
8319 return ret;
8335 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
8366 ret = mbedtls_md_setup(&cloned_ctx, mbedtls_md_info_from_ctx(hs_ctx), 0);
8367 if (ret != 0) {
8370 ret = mbedtls_md_clone(&cloned_ctx, hs_ctx);
8371 if (ret != 0) {
8375 ret = mbedtls_md_finish(&cloned_ctx, padbuf);
8376 if (ret != 0) {
8403 return ret;
8527 int ret;
8534 ret = ssl->handshake->calc_finished(ssl, ssl->out_msg + 4, ssl->conf->endpoint);
8535 if (ret != 0) {
8536 MBEDTLS_SSL_DEBUG_RET(1, "calc_finished", ret);
8619 if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
8620 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
8621 return ret;
8626 (ret = mbedtls_ssl_flight_transmit(ssl)) != 0) {
8627 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_flight_transmit", ret);
8628 return ret;
8641 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
8647 ret = ssl->handshake->calc_finished(ssl, buf, ssl->conf->endpoint ^ 1);
8648 if (ret != 0) {
8649 MBEDTLS_SSL_DEBUG_RET(1, "calc_finished", ret);
8652 if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) {
8653 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_read_record", ret);
8661 ret = MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE;
8668 ret = MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE;
8676 ret = MBEDTLS_ERR_SSL_DECODE_ERROR;
8685 ret = MBEDTLS_ERR_SSL_HANDSHAKE_FAILURE;
8719 return ret;
8801 int ret = 0;
8873 ret = PSA_TO_MBEDTLS_ERR(status);
8874 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_cipher_to_psa", ret);
8924 ret = tls_prf(master, 48, "key expansion", randbytes, 64, keyblk, 256);
8925 if (ret != 0) {
8926 MBEDTLS_SSL_DEBUG_RET(1, "prf", ret);
8927 return ret;
8997 if ((ret = mbedtls_md_setup(&transform->md_ctx_enc, md_info, 1)) != 0 ||
8998 (ret = mbedtls_md_setup(&transform->md_ctx_dec, md_info, 1)) != 0) {
8999 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_setup", ret);
9041 ret = MBEDTLS_ERR_SSL_INTERNAL_ERROR;
9093 ret = MBEDTLS_ERR_SSL_INTERNAL_ERROR;
9119 ret = PSA_TO_MBEDTLS_ERR(status);
9120 MBEDTLS_SSL_DEBUG_RET(1, "psa_import_key", ret);
9130 ret = PSA_TO_MBEDTLS_ERR(status);
9131 MBEDTLS_SSL_DEBUG_RET(1, "psa_import_key", ret);
9136 if ((ret = mbedtls_cipher_setup(&transform->cipher_ctx_enc,
9138 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_setup", ret);
9142 if ((ret = mbedtls_cipher_setup(&transform->cipher_ctx_dec,
9144 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_setup", ret);
9148 if ((ret = mbedtls_cipher_setkey(&transform->cipher_ctx_enc, key1,
9151 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_setkey", ret);
9155 if ((ret = mbedtls_cipher_setkey(&transform->cipher_ctx_dec, key2,
9158 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_setkey", ret);
9164 if ((ret = mbedtls_cipher_set_padding_mode(&transform->cipher_ctx_enc,
9166 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_set_padding_mode", ret);
9170 if ((ret = mbedtls_cipher_set_padding_mode(&transform->cipher_ctx_dec,
9172 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_set_padding_mode", ret);
9193 ret = PSA_TO_MBEDTLS_ERR(status);
9194 MBEDTLS_SSL_DEBUG_RET(1, "psa_import_mac_key", ret);
9214 ret = PSA_TO_MBEDTLS_ERR(status);
9215 MBEDTLS_SSL_DEBUG_RET(1, "psa_import_mac_key", ret);
9219 ret = mbedtls_md_hmac_starts(&transform->md_ctx_enc, mac_enc, mac_key_len);
9220 if (ret != 0) {
9223 ret = mbedtls_md_hmac_starts(&transform->md_ctx_dec, mac_dec, mac_key_len);
9224 if (ret != 0) {
9236 return ret;
9388 int ret = 0;
9404 if ((ret = mbedtls_md_setup(&ctx, md_info, 0)) != 0) {
9405 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_setup", ret);
9408 if ((ret = mbedtls_md_starts(&ctx)) != 0) {
9409 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_starts", ret);
9412 if ((ret = mbedtls_md_update(&ctx, ssl->handshake->randbytes, 64)) != 0) {
9413 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_update", ret);
9416 if ((ret = mbedtls_md_update(&ctx, data, data_len)) != 0) {
9417 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_update", ret);
9420 if ((ret = mbedtls_md_finish(&ctx, hash)) != 0) {
9421 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_finish", ret);
9428 if (ret != 0) {
9433 return ret;
9674 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
9704 ret = ssl->conf->f_sni(ssl->conf->p_sni,
9706 if (ret != 0) {
9707 MBEDTLS_SSL_DEBUG_RET(1, "ssl_sni_wrapper", ret);