Lines Matching defs:session
451 static int ssl_tls12_session_load(mbedtls_ssl_session *session,
495 static void ssl_clear_peer_cert(mbedtls_ssl_session *session)
498 if (session->peer_cert != NULL) {
499 mbedtls_x509_crt_free(session->peer_cert);
500 mbedtls_free(session->peer_cert);
501 session->peer_cert = NULL;
504 if (session->peer_cert_digest != NULL) {
506 mbedtls_free(session->peer_cert_digest);
507 session->peer_cert_digest = NULL;
508 session->peer_cert_digest_type = MBEDTLS_MD_NONE;
509 session->peer_cert_digest_len = 0;
1043 void mbedtls_ssl_session_init(mbedtls_ssl_session *session)
1045 memset(session, 0, sizeof(mbedtls_ssl_session));
1586 if (ssl->session) {
1587 mbedtls_ssl_session_free(ssl->session);
1588 mbedtls_free(ssl->session);
1589 ssl->session = NULL;
1746 int mbedtls_ssl_set_session(mbedtls_ssl_context *ssl, const mbedtls_ssl_session *session)
1751 session == NULL ||
1762 if (session->tls_version == MBEDTLS_SSL_VERSION_TLS1_3) {
1764 mbedtls_ssl_ciphersuite_from_id(session->ciphersuite);
1770 session->ciphersuite));
1777 session)) != 0) {
3082 if (ssl->session != NULL) {
3083 return ssl->session->verify_result;
3095 if (ssl == NULL || ssl->session == NULL) {
3099 return ssl->session->ciphersuite;
3104 if (ssl == NULL || ssl->session == NULL) {
3108 return mbedtls_ssl_get_ciphersuite_name(ssl->session->ciphersuite);
3141 if (ssl->session != NULL &&
3142 ssl->session->record_size_limit >= MBEDTLS_SSL_RECORD_SIZE_LIMIT_MIN &&
3143 ssl->session->record_size_limit < max_len) {
3144 record_size_limit = ssl->session->record_size_limit;
3334 if (ssl == NULL || ssl->session == NULL) {
3339 return ssl->session->peer_cert;
3354 ssl->session == NULL ||
3360 * idempotent: Each session can only be exported once.
3367 * Check whether we have already exported the current session,
3370 if (ssl->session->exported == 1) {
3374 ret = mbedtls_ssl_session_copy(dst, ssl->session);
3379 /* Remember that we've exported the session. */
3380 ssl->session->exported = 1;
3391 static size_t ssl_tls12_session_save(const mbedtls_ssl_session *session,
3414 start = (uint64_t) session->start;
3425 + sizeof(session->id)
3426 + sizeof(session->master)
3430 *p++ = MBEDTLS_BYTE_0(session->id_len);
3431 memcpy(p, session->id, 32);
3434 memcpy(p, session->master, 48);
3437 MBEDTLS_PUT_UINT32_BE(session->verify_result, p, 0);
3446 if (session->peer_cert == NULL) {
3449 cert_len = session->peer_cert->raw.len;
3459 if (session->peer_cert != NULL) {
3460 memcpy(p, session->peer_cert->raw.p, cert_len);
3465 if (session->peer_cert_digest != NULL) {
3466 used += 1 /* type */ + 1 /* length */ + session->peer_cert_digest_len;
3468 *p++ = (unsigned char) session->peer_cert_digest_type;
3469 *p++ = (unsigned char) session->peer_cert_digest_len;
3470 memcpy(p, session->peer_cert_digest,
3471 session->peer_cert_digest_len);
3472 p += session->peer_cert_digest_len;
3489 if (session->endpoint == MBEDTLS_SSL_IS_CLIENT) {
3490 used += 3 + session->ticket_len + 4; /* len + ticket + lifetime */
3493 *p++ = MBEDTLS_BYTE_2(session->ticket_len);
3494 *p++ = MBEDTLS_BYTE_1(session->ticket_len);
3495 *p++ = MBEDTLS_BYTE_0(session->ticket_len);
3497 if (session->ticket != NULL) {
3498 memcpy(p, session->ticket, session->ticket_len);
3499 p += session->ticket_len;
3502 MBEDTLS_PUT_UINT32_BE(session->ticket_lifetime, p, 0);
3508 if (session->endpoint == MBEDTLS_SSL_IS_SERVER) {
3512 MBEDTLS_PUT_UINT64_BE((uint64_t) session->ticket_creation_time, p, 0);
3526 *p++ = session->mfl_code;
3534 *p++ = MBEDTLS_BYTE_0(session->encrypt_then_mac);
3542 static int ssl_tls12_session_load(mbedtls_ssl_session *session,
3569 session->start = (time_t) start;
3579 session->id_len = *p++;
3580 memcpy(session->id, p, 32);
3583 memcpy(session->master, p, 48);
3586 session->verify_result = MBEDTLS_GET_UINT32_BE(p, 0);
3593 session->peer_cert = NULL;
3595 session->peer_cert_digest = NULL;
3599 session->ticket = NULL;
3622 session->peer_cert = mbedtls_calloc(1, sizeof(mbedtls_x509_crt));
3624 if (session->peer_cert == NULL) {
3628 mbedtls_x509_crt_init(session->peer_cert);
3630 if ((ret = mbedtls_x509_crt_parse_der(session->peer_cert,
3632 mbedtls_x509_crt_free(session->peer_cert);
3633 mbedtls_free(session->peer_cert);
3634 session->peer_cert = NULL;
3646 session->peer_cert_digest_type = (mbedtls_md_type_t) *p++;
3647 session->peer_cert_digest_len = (size_t) *p++;
3649 if (session->peer_cert_digest_len != 0) {
3651 mbedtls_md_info_from_type(session->peer_cert_digest_type);
3655 if (session->peer_cert_digest_len != mbedtls_md_get_size(md_info)) {
3659 if (session->peer_cert_digest_len > (size_t) (end - p)) {
3663 session->peer_cert_digest =
3664 mbedtls_calloc(1, session->peer_cert_digest_len);
3665 if (session->peer_cert_digest == NULL) {
3669 memcpy(session->peer_cert_digest, p,
3670 session->peer_cert_digest_len);
3671 p += session->peer_cert_digest_len;
3681 if (session->endpoint == MBEDTLS_SSL_IS_CLIENT) {
3686 session->ticket_len = MBEDTLS_GET_UINT24_BE(p, 0);
3689 if (session->ticket_len != 0) {
3690 if (session->ticket_len > (size_t) (end - p)) {
3694 session->ticket = mbedtls_calloc(1, session->ticket_len);
3695 if (session->ticket == NULL) {
3699 memcpy(session->ticket, p, session->ticket_len);
3700 p += session->ticket_len;
3707 session->ticket_lifetime = MBEDTLS_GET_UINT32_BE(p, 0);
3712 if (session->endpoint == MBEDTLS_SSL_IS_SERVER) {
3716 session->ticket_creation_time = MBEDTLS_GET_UINT64_BE(p, 0);
3730 session->mfl_code = *p++;
3738 session->encrypt_then_mac = *p++;
3758 static int ssl_tls13_session_save(const mbedtls_ssl_session *session,
3766 size_t hostname_len = (session->hostname == NULL) ?
3767 0 : strlen(session->hostname) + 1;
3772 const size_t alpn_len = (session->ticket_alpn == NULL) ?
3773 0 : strlen(session->ticket_alpn) + 1;
3781 if (session->resumption_key_len > MBEDTLS_SSL_TLS1_3_TICKET_RESUMPTION_KEY_LEN) {
3784 needed += session->resumption_key_len; /* resumption_key */
3798 if (session->endpoint == MBEDTLS_SSL_IS_SERVER) {
3807 if (session->endpoint == MBEDTLS_SSL_IS_CLIENT) {
3817 if (session->ticket_len > SIZE_MAX - needed) {
3821 needed += session->ticket_len; /* ticket */
3830 MBEDTLS_PUT_UINT32_BE(session->ticket_age_add, p, 0);
3831 p[4] = session->ticket_flags;
3834 p[5] = session->resumption_key_len;
3836 memcpy(p, session->resumption_key, session->resumption_key_len);
3837 p += session->resumption_key_len;
3840 MBEDTLS_PUT_UINT32_BE(session->max_early_data_size, p, 0);
3844 MBEDTLS_PUT_UINT16_BE(session->record_size_limit, p, 0);
3849 if (session->endpoint == MBEDTLS_SSL_IS_SERVER) {
3851 MBEDTLS_PUT_UINT64_BE((uint64_t) session->ticket_creation_time, p, 0);
3861 memcpy(p, session->ticket_alpn, alpn_len);
3869 if (session->endpoint == MBEDTLS_SSL_IS_CLIENT) {
3875 memcpy(p, session->hostname, hostname_len);
3881 MBEDTLS_PUT_UINT64_BE((uint64_t) session->ticket_reception_time, p, 0);
3884 MBEDTLS_PUT_UINT32_BE(session->ticket_lifetime, p, 0);
3887 MBEDTLS_PUT_UINT16_BE(session->ticket_len, p, 0);
3890 if (session->ticket != NULL && session->ticket_len > 0) {
3891 memcpy(p, session->ticket, session->ticket_len);
3892 p += session->ticket_len;
3900 static int ssl_tls13_session_load(mbedtls_ssl_session *session,
3910 session->ticket_age_add = MBEDTLS_GET_UINT32_BE(p, 0);
3911 session->ticket_flags = p[4];
3914 session->resumption_key_len = p[5];
3917 if (end - p < session->resumption_key_len) {
3921 if (sizeof(session->resumption_key) < session->resumption_key_len) {
3924 memcpy(session->resumption_key, p, session->resumption_key_len);
3925 p += session->resumption_key_len;
3931 session->max_early_data_size = MBEDTLS_GET_UINT32_BE(p, 0);
3938 session->record_size_limit = MBEDTLS_GET_UINT16_BE(p, 0);
3943 if (session->endpoint == MBEDTLS_SSL_IS_SERVER) {
3948 session->ticket_creation_time = MBEDTLS_GET_UINT64_BE(p, 0);
3967 int ret = mbedtls_ssl_session_set_ticket_alpn(session, (char *) p);
3978 if (session->endpoint == MBEDTLS_SSL_IS_CLIENT) {
3992 session->hostname = mbedtls_calloc(1, hostname_len);
3993 if (session->hostname == NULL) {
3996 memcpy(session->hostname, p, hostname_len);
4005 session->ticket_reception_time = MBEDTLS_GET_UINT64_BE(p, 0);
4011 session->ticket_lifetime = MBEDTLS_GET_UINT32_BE(p, 0);
4017 session->ticket_len = MBEDTLS_GET_UINT16_BE(p, 0);
4020 if (end - p < (long int) session->ticket_len) {
4023 if (session->ticket_len > 0) {
4024 session->ticket = mbedtls_calloc(1, session->ticket_len);
4025 if (session->ticket == NULL) {
4028 memcpy(session->ticket, p, session->ticket_len);
4029 p += session->ticket_len;
4039 static int ssl_tls13_session_save(const mbedtls_ssl_session *session,
4044 ((void) session);
4051 static int ssl_tls13_session_load(const mbedtls_ssl_session *session,
4055 ((void) session);
4180 * Serialize a session in the following format:
4183 * TLS 1.2 session:
4255 * SSL session:
4292 static int ssl_session_save(const mbedtls_ssl_session *session,
4305 if (session == NULL) {
4329 *p++ = MBEDTLS_BYTE_0(session->tls_version);
4330 *p++ = session->endpoint;
4331 MBEDTLS_PUT_UINT16_BE(session->ciphersuite, p, 0);
4337 switch (session->tls_version) {
4340 used += ssl_tls12_session_save(session, p, remaining_len);
4346 ret = ssl_tls13_session_save(session, p, remaining_len, &out_len);
4369 int mbedtls_ssl_session_save(const mbedtls_ssl_session *session,
4374 return ssl_session_save(session, 0, buf, buf_len, olen);
4378 * Deserialize session, see mbedtls_ssl_session_save() for format.
4384 static int ssl_session_load(mbedtls_ssl_session *session,
4394 if (session == NULL) {
4420 session->tls_version = (mbedtls_ssl_protocol_version) (0x0300 | *p++);
4421 session->endpoint = *p++;
4422 session->ciphersuite = MBEDTLS_GET_UINT16_BE(p, 0);
4427 switch (session->tls_version) {
4430 return ssl_tls12_session_load(session, p, remaining_len);
4435 return ssl_tls13_session_load(session, p, remaining_len);
4444 * Deserialize session: public wrapper for error cleaning
4446 int mbedtls_ssl_session_load(mbedtls_ssl_session *session,
4450 int ret = ssl_session_load(session, 0, buf, len);
4453 mbedtls_ssl_session_free(session);
4921 void mbedtls_ssl_session_free(mbedtls_ssl_session *session)
4923 if (session == NULL) {
4928 ssl_clear_peer_cert(session);
4934 mbedtls_free(session->hostname);
4936 mbedtls_free(session->ticket);
4941 mbedtls_free(session->ticket_alpn);
4944 mbedtls_platform_zeroize(session, sizeof(mbedtls_ssl_session));
5010 * // session sub-structure
5011 * opaque session<1..2^32-1>; // see mbedtls_ssl_session_save()
5029 * 2. pointer to dynamically-allocated memory (eg session, transform)
5030 * 3. value can be re-derived from other data (eg session keys from MS)
5062 if (ssl->transform == NULL || ssl->session == NULL) {
5112 ret = ssl_session_save(ssl->session, 1, NULL, 0, &session_len);
5122 ret = ssl_session_save(ssl->session, 1,
5249 * (Checking session is useful because it won't be NULL if we're
5250 * renegotiating, or if the user mistakenly loaded a session first.)
5253 ssl->session != NULL) {
5299 ssl->session = ssl->session_negotiate;
5300 ssl->session_in = ssl->session;
5301 ssl->session_out = ssl->session;
5308 ret = ssl_session_load(ssl->session, 1, p, session_len);
5310 mbedtls_ssl_session_free(ssl->session);
5330 prf_func = ssl_tls12prf_from_cs(ssl->session->ciphersuite);
5341 ssl->session->ciphersuite,
5342 ssl->session->master,
5344 ssl->session->encrypt_then_mac,
5568 if (ssl->session) {
5569 mbedtls_ssl_session_free(ssl->session);
5570 mbedtls_free(ssl->session);
7047 MBEDTLS_SSL_DEBUG_MSG(3, ("no premaster (session resumed)"));
7060 MBEDTLS_SSL_DEBUG_BUF(3, "session hash for extended master secret",
7678 mbedtls_x509_crt const * const peer_crt = ssl->session->peer_cert;
7698 ssl->session->peer_cert_digest;
7700 ssl->session->peer_cert_digest_type;
7831 ssl_clear_peer_cert(ssl->session);
8223 * reuse a session but it failed, and allocate a new one. */
8294 /* Pass ownership to session structure. */
8341 mbedtls_ssl_session *session = ssl->session_negotiate;
8342 if (!session) {
8343 session = ssl->session;
8388 ssl->handshake->tls_prf(session->master, 48, sender,
8478 * Free the previous session and switch in the current one
8480 if (ssl->session) {
8484 ssl->session->encrypt_then_mac;
8487 mbedtls_ssl_session_free(ssl->session);
8488 mbedtls_free(ssl->session);
8490 ssl->session = ssl->session_negotiate;
8497 ssl->session->id_len != 0 &&
8500 ssl->session->id,
8501 ssl->session->id_len,
8502 ssl->session) != 0) {
8503 MBEDTLS_SSL_DEBUG_MSG(1, ("cache did not store session"));
8557 * In case of session resuming, invert the client and server
8576 * Switch to our negotiated transform and session parameters for outbound
8769 * Populate a transform structure with session keys and all the other
9848 int mbedtls_ssl_session_set_hostname(mbedtls_ssl_session *session,
9866 if (session->hostname != NULL) {
9867 mbedtls_zeroize_and_free(session->hostname,
9868 strlen(session->hostname));
9873 session->hostname = NULL;
9875 session->hostname = mbedtls_calloc(1, hostname_len + 1);
9876 if (session->hostname == NULL) {
9880 memcpy(session->hostname, hostname, hostname_len);
9892 int mbedtls_ssl_session_set_ticket_alpn(mbedtls_ssl_session *session,
9905 if (session->ticket_alpn != NULL) {
9906 mbedtls_zeroize_and_free(session->ticket_alpn,
9907 strlen(session->ticket_alpn));
9908 session->ticket_alpn = NULL;
9912 session->ticket_alpn = mbedtls_calloc(alpn_len + 1, 1);
9913 if (session->ticket_alpn == NULL) {
9916 memcpy(session->ticket_alpn, alpn, alpn_len);