Set default value of early date size for client to 0

This commit sets the default value of "early_data_size" to 0 for
the client. "early_data_size" is set to a non-zero value when the
server sends the relevant extension in a session ticket to the
client.

This makes it easy for the client to determine if a server
supports early data.

Link: https://gitlab.com/gnutls/gnutls/-/issues/1619
Signed-off-by: Sahil Siddiq <sahilcdq@proton.me>

diff --git a/lib/state.c b/lib/state.c
index f2c74d97d0b1018f7803272c3846829825163207..9d3ece757066460d00c641cda4416d329ce033cc 100644 (file)
--- a/lib/state.c
+++ b/lib/state.c
@@ -660,8 +660,7 @@ int gnutls_init(gnutls_session_t *session, unsigned int flags)
                (*session)->security_parameters.max_early_data_size =
                        DEFAULT_MAX_EARLY_DATA_SIZE;
        } else {
-               (*session)->security_parameters.max_early_data_size =
-                       UINT32_MAX;
+               (*session)->security_parameters.max_early_data_size = 0;
        }
 
        /* Everything else not initialized here is initialized as NULL

diff --git a/tests/tls13-early-data-neg2.c b/tests/tls13-early-data-neg2.c
index d1f485e03eb802aab480ea03e52b0a439c057a0a..b9fb44938541cdf932609e8d8258838ff59be5bb 100644 (file)
--- a/tests/tls13-early-data-neg2.c
+++ b/tests/tls13-early-data-neg2.c
@@ -54,6 +54,8 @@ int main(void)
 #include "virt-time.h"
 
 /* This program checks that early data is refused upon resumption failure.
+ * It also checks that early data size is zero for the client unless the
+ * server explicitly negotiates the "early_data" extension.
  */
 
 static void server_log_func(int level, const char *str)
@@ -66,11 +68,12 @@ static void client_log_func(int level, const char *str)
        fprintf(stderr, "client|<%d>| %s", level, str);
 }
 
-#define SESSIONS 2
+#define SESSIONS 3
 #define MAX_BUF 1024
 #define MSG "Hello TLS"
 #define EARLY_MSG "Hello TLS, it's early"
 #define PRIORITY "NORMAL:-VERS-ALL:+VERS-TLS1.3"
+#define DEFAULT_MAX_EARLY_DATA_SIZE 16384
 
 static void client(int sds[])
 {
@@ -105,13 +108,35 @@ static void client(int sds[])
 
                gnutls_transport_set_int(session, sd);
 
+               if (gnutls_record_get_max_early_data_size(session) != 0)
+                       fail("client: max_early_data_size not 0 before connection\n");
+
                if (t > 0) {
                        assert(gnutls_session_set_data(session,
                                                       session_data.data,
                                                       session_data.size) >= 0);
-                       assert(gnutls_record_send_early_data(
-                                      session, EARLY_MSG, sizeof(EARLY_MSG)) >=
-                              0);
+                       if (t == 1) {
+                               if (gnutls_record_get_max_early_data_size(
+                                           session) != 0)
+                                       fail("client: unexpected non-zero value of max_early_data_size = %d\n",
+                                            (int)gnutls_record_get_max_early_data_size(
+                                                    session));
+                               if (gnutls_record_send_early_data(
+                                           session, EARLY_MSG,
+                                           sizeof(EARLY_MSG)) >= 0)
+                                       fail("client: unexpected early data sent\n");
+                       } else {
+                               if (gnutls_record_get_max_early_data_size(
+                                           session) !=
+                                   DEFAULT_MAX_EARLY_DATA_SIZE)
+                                       fail("client: max_early_data_size mismatch %d != %d\n",
+                                            (int)gnutls_record_get_max_early_data_size(
+                                                    session),
+                                            DEFAULT_MAX_EARLY_DATA_SIZE);
+                               assert(gnutls_record_send_early_data(
+                                              session, EARLY_MSG,
+                                              sizeof(EARLY_MSG)) >= 0);
+                       }
                }
 
                /* Perform the TLS handshake
@@ -129,7 +154,7 @@ static void client(int sds[])
                                success("client: Handshake was completed\n");
                }
 
-               if (t == 0) {
+               if (t < 2) {
                        /* get the session data size */
                        ret = gnutls_session_get_data2(session, &session_data);
                        if (ret < 0)
@@ -264,12 +289,14 @@ static void server(int sds[])
                gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE,
                                       x509_cred);
 
-               /* Intentionally overwrite the previous key to cause resumption
-                * failure. */
-               gnutls_session_ticket_key_generate(&session_ticket_key);
+               if (t > 0) {
+                       /* Intentionally overwrite the previous key to cause resumption
+                        * failure. */
+                       gnutls_session_ticket_key_generate(&session_ticket_key);
 
-               gnutls_session_ticket_enable_server(session,
-                                                   &session_ticket_key);
+                       gnutls_session_ticket_enable_server(
+                               session, &session_ticket_key);
+               }
 
                gnutls_anti_replay_enable(session, anti_replay);
 

diff --git a/tests/tls13-early-data.c b/tests/tls13-early-data.c
index 6613e413d567731c4f728450afad612ecc780bba..ad2244d2e7f0cb5e1c5fa8cd082de8a47a1b324a 100644 (file)
--- a/tests/tls13-early-data.c
+++ b/tests/tls13-early-data.c
@@ -462,6 +462,9 @@ static void client(int sds[], const struct fixture *fixture)
                gnutls_session_set_ptr(session, &callback_data);
                gnutls_handshake_set_secret_function(session, secret_callback);
 
+               if (gnutls_record_get_max_early_data_size(session) != 0)
+                       fail("client: max_early_data_size not 0 before connection\n");
+
                if (t > 0) {
                        assert(gnutls_session_set_data(session,
                                                       session_data.data,
@@ -486,6 +489,11 @@ static void client(int sds[], const struct fixture *fixture)
                        ret = gnutls_handshake(session);
                } while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
 
+               if (t == 0) {
+                       if (gnutls_record_get_max_early_data_size(session) != 0)
+                               fail("client: max_early_data_size not 0 after initial connection\n");
+               }
+
                if (ret < 0) {
                        fail("client: Handshake failed: %s\n",
                             gnutls_strerror(ret));