Merge branch 'fix/https_request_example_test' into 'master'

https_request_example: Update the example test to use local python server

See merge request espressif/esp-idf!15931

examples/protocols/https_request/example_test.py

@@ -1,12 +1,178 @@
+import http.server
+import multiprocessing
 import os
 import re
+import socket
+import ssl
 
 import ttfw_idf
-from tiny_test_fw import Utility
+from RangeHTTPServer import RangeRequestHandler
+from tiny_test_fw import DUT, Utility
+
+
+def get_my_ip():
+    s1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s1.connect(('8.8.8.8', 80))
+    my_ip = s1.getsockname()[0]
+    s1.close()
+    return my_ip
+
+
+def get_server_status(host_ip, port):
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server_status = sock.connect_ex((host_ip, port))
+    sock.close()
+    if server_status == 0:
+        return True
+    return False
+
+
+def https_request_handler():
+    """
+    Returns a request handler class that handles broken pipe exception
+    """
+    class RequestHandler(RangeRequestHandler):
+        protocol_version = 'HTTP/1.1'
+
+        def finish(self):
+            try:
+                if not self.wfile.closed:
+                    self.wfile.flush()
+                    self.wfile.close()
+            except socket.error:
+                pass
+            self.rfile.close()
+
+        def handle(self):
+            try:
+                RangeRequestHandler.handle(self)
+            except socket.error:
+                pass
+
+        def do_GET(self):
+            self.close_connection = True
+            self.send_response(200)
+            self.end_headers()
+
+    return RequestHandler
+
+
+def start_https_server(server_file, key_file, server_ip, server_port):
+
+    requestHandler = https_request_handler()
+    httpd = http.server.HTTPServer((server_ip, server_port), requestHandler)
+
+    httpd.socket = ssl.wrap_socket(httpd.socket, keyfile=key_file,
+                                   certfile=server_file, server_side=True)
+    httpd.serve_forever()
+
+
+@ttfw_idf.idf_example_test(env_tag='Example_EthKitV1')
+def test_examples_protocol_https_request_cli_session_tickets(env, extra_data):
+    Utility.console_log("Testing for \"esp_tls client session tickets\"")
+
+    dut1 = env.get_dut('https_request_ses_tkt', 'examples/protocols/https_request', dut_class=ttfw_idf.ESP32DUT, app_config_name='cli_ses_tkt')
+    Utility.console_log('[app_config_name] - {}'.format(dut1.app.config_name))
+    # check and log bin size
+    binary_file = os.path.join(dut1.app.binary_path, 'https_request.bin')
+    bin_size = os.path.getsize(binary_file)
+    ttfw_idf.log_performance('https_request_bin_size', '{}KB'.format(bin_size // 1024))
+    # start test
+    host_ip = get_my_ip()
+    server_port = 8070
+    server_file = os.path.join(os.path.dirname(__file__), 'main', 'local_server_cert.pem')
+    key_file = os.path.join(os.path.dirname(__file__), 'main', 'local_server_key.pem')
+    if (get_server_status(host_ip, server_port) is False):
+        thread1 = multiprocessing.Process(target=start_https_server, args=(server_file, key_file, host_ip, server_port))
+        thread1.daemon = True
+        thread1.start()
+    Utility.console_log('The server started on {}:{}'.format(host_ip, server_port))
+    dut1.start_app()
+
+    dut1.expect('Loaded app from partition at offset', timeout=30)
+    try:
+        ip_address = dut1.expect(re.compile(r' (sta|eth) ip: ([^,]+),'), timeout=60)
+        print('Connected to AP with IP: {}'.format(ip_address))
+    except DUT.ExpectTimeout:
+        raise ValueError('ENV_TEST_FAILURE: Cannot connect to AP')
+
+    dut1.expect('Start https_request example', timeout=30)
+
+    print('writing to device: {}'.format('https://' + host_ip + ':' + str(server_port)))
+
+    dut1.write('https://' + host_ip + ':' + str(server_port))
+    Utility.console_log("Testing for \"https_request using saved session\"")
+
+    # Check for connection using already saved client session
+    try:
+        dut1.expect(re.compile('https_request to local server'), timeout=30)
+        dut1.expect_all('Connection established...',
+                        'Reading HTTP response...',
+                        'HTTP/1.1 200 OK',
+                        re.compile('connection closed'))
+    except Exception:
+        Utility.console_log("Failed to connect to local https server\"")
+        raise
+
+    try:
+        dut1.expect(re.compile('https_request using saved client session'), timeout=20)
+        dut1.expect_all('Connection established...',
+                        'Reading HTTP response...',
+                        'HTTP/1.1 200 OK',
+                        re.compile('connection closed'))
+    except Exception:
+        Utility.console_log("Failed the test for \"https_request using saved client session\"")
+        raise
+
+    Utility.console_log("Passed the test for \"https_request using saved client session\"")
+    thread1.terminate()
+    env.close_dut('https_request_ses_tkt')
+
+
+@ttfw_idf.idf_example_test(env_tag='Example_EthKitV1')
+def test_examples_protocol_https_request_dynamic_buffers(env, extra_data):
+    # Check for connection using crt bundle with mbedtls dynamic resource enabled
+    dut1 = env.get_dut('https_request_ssldyn', 'examples/protocols/https_request', dut_class=ttfw_idf.ESP32DUT, app_config_name='ssldyn')
+    # check and log bin size
+    Utility.console_log('[app_config_name] - {}'.format(dut1.app.config_name))
+    binary_file = os.path.join(dut1.app.binary_path, 'https_request.bin')
+    bin_size = os.path.getsize(binary_file)
+    ttfw_idf.log_performance('https_request_bin_size', '{}KB'.format(bin_size // 1024))
+    # start test
+    dut1.start_app()
+
+    dut1.expect('Loaded app from partition at offset', timeout=30)
+    try:
+        ip_address = dut1.expect(re.compile(r' (sta|eth) ip: ([^,]+),'), timeout=60)
+        print('Connected to AP with IP: {}'.format(ip_address))
+    except DUT.ExpectTimeout:
+        raise ValueError('ENV_TEST_FAILURE: Cannot connect to AP')
+
+    # only check if one connection is established
+    Utility.console_log("Testing for \"https_request using crt bundle\" with mbedtls dynamic resource enabled")
+    try:
+        dut1.expect(re.compile('https_request using crt bundle'), timeout=30)
+        dut1.expect_all('Connection established...',
+                        'Reading HTTP response...',
+                        'HTTP/1.1 200 OK',
+                        re.compile('connection closed'))
+    except Exception:
+        Utility.console_log("Failed the test for \"https_request using crt bundle\" when mbedtls dynamic resource was enabled")
+        raise
+    Utility.console_log("Passed the test for \"https_request using crt bundle\" when mbedtls dynamic resource was enabled")
+
+    # Read free heap size
+    res = dut1.expect(ttfw_idf.MINIMUM_FREE_HEAP_SIZE_RE,timeout=20)
+    if not res:
+        raise ValueError('Maximum heap size info not found')
+    ttfw_idf.print_heap_size('https_request', dut1.app.config_name, dut1.TARGET, res[0])
+
+    env.close_dut('https_request_ssldyn')
 
 
 @ttfw_idf.idf_example_test(env_tag='Example_EthKitV1')
 def test_examples_protocol_https_request(env, extra_data):
+
     """
     steps: |
       1. join AP
@@ -16,6 +182,7 @@ def test_examples_protocol_https_request(env, extra_data):
     """
     dut1 = env.get_dut('https_request', 'examples/protocols/https_request', dut_class=ttfw_idf.ESP32DUT)
     # check and log bin size
+    Utility.console_log('[app_config_name] - {}'.format(dut1.app.config_name))
     binary_file = os.path.join(dut1.app.binary_path, 'https_request.bin')
     bin_size = os.path.getsize(binary_file)
     ttfw_idf.log_performance('https_request_bin_size', '{}KB'.format(bin_size // 1024))
@@ -23,6 +190,13 @@ def test_examples_protocol_https_request(env, extra_data):
     Utility.console_log('Starting https_request simple test app')
     dut1.start_app()
 
+    dut1.expect('Loaded app from partition at offset', timeout=30)
+    try:
+        ip_address = dut1.expect(re.compile(r' (sta|eth) ip: ([^,]+),'), timeout=60)
+        print('Connected to AP with IP: {}'.format(ip_address))
+    except DUT.ExpectTimeout:
+        raise ValueError('ENV_TEST_FAILURE: Cannot connect to AP')
+
     # Check for connection using crt bundle
     Utility.console_log("Testing for \"https_request using crt bundle\"")
     try:
@@ -37,6 +211,12 @@ def test_examples_protocol_https_request(env, extra_data):
         raise
     Utility.console_log("Passed the test for \"https_request using crt bundle\"")
 
+    # Read free heap size
+    res = dut1.expect(ttfw_idf.MINIMUM_FREE_HEAP_SIZE_RE,timeout=20)
+    if not res:
+        raise ValueError('Maximum heap size info not found')
+    ttfw_idf.print_heap_size('https_request', dut1.app.config_name, dut1.TARGET, res[0])
+
     # Check for connection using cacert_buf
     Utility.console_log("Testing for \"https_request using cacert_buf\"")
     try:
@@ -62,41 +242,10 @@ def test_examples_protocol_https_request(env, extra_data):
         Utility.console_log("Failed the test for \"https_request using global ca_store\"")
         raise
     Utility.console_log("Passed the test for \"https_request using global ca_store\"")
-
-    # Check for connection using already saved client session
-    Utility.console_log("Testing for \"https_request using saved client session\"")
-    try:
-        dut1.expect(re.compile('https_request using saved client session'), timeout=20)
-        dut1.expect_all('Connection established...',
-                        'Reading HTTP response...',
-                        'HTTP/1.1 200 OK',
-                        re.compile('connection closed'))
-    except Exception:
-        Utility.console_log("Failed the test for \"https_request using saved client session\"")
-        raise
-    Utility.console_log("Passed the test for \"https_request using saved client session\"")
-
-    # Check for connection using crt bundle with mbedtls dynamic resource enabled
-    dut1 = env.get_dut('https_request', 'examples/protocols/https_request', dut_class=ttfw_idf.ESP32DUT, app_config_name='ssldyn')
-    # check and log bin size
-    binary_file = os.path.join(dut1.app.binary_path, 'https_request.bin')
-    bin_size = os.path.getsize(binary_file)
-    ttfw_idf.log_performance('https_request_bin_size', '{}KB'.format(bin_size // 1024))
-    # start test
-    dut1.start_app()
-    # only check if one connection is established
-    Utility.console_log("Testing for \"https_request using crt bundle\" with mbedtls dynamic resource enabled")
-    try:
-        dut1.expect(re.compile('https_request using crt bundle'), timeout=30)
-        dut1.expect_all('Connection established...',
-                        'Reading HTTP response...',
-                        'HTTP/1.1 200 OK',
-                        re.compile('connection closed'))
-    except Exception:
-        Utility.console_log("Failed the test for \"https_request using crt bundle\" when mbedtls dynamic resource was enabled")
-        raise
-    Utility.console_log("Passed the test for \"https_request using crt bundle\" when mbedtls dynamic resource was enabled")
+    env.close_dut('https_request')
 
 
 if __name__ == '__main__':
     test_examples_protocol_https_request()
+    test_examples_protocol_https_request_cli_session_tickets()
+    test_examples_protocol_https_request_dynamic_buffers()

examples/protocols/https_request/main/CMakeLists.txt

@@ -3,4 +3,4 @@
 # (If this was a component, we would set COMPONENT_EMBED_TXTFILES here.)
 idf_component_register(SRCS "https_request_example_main.c" "time_sync.c"
                     INCLUDE_DIRS "include"
-                    EMBED_TXTFILES server_root_cert.pem)
+                    EMBED_TXTFILES server_root_cert.pem local_server_cert.pem)

examples/protocols/https_request/main/Kconfig.projbuild

@@ -0,0 +1,21 @@
+menu "Example Configuration"
+
+    config EXAMPLE_CLIENT_SESSION_TICKETS
+        bool "Enable Client session ticket support"
+        default n
+        select ESP_TLS_CLIENT_SESSION_TICKETS
+        help
+            Enable the client session ticket support for the example.
+
+    config EXAMPLE_LOCAL_SERVER_URL
+        string "Local Server URL for testing session tickets"
+        default "https://192.168.0.106:8070"
+        depends on EXAMPLE_CLIENT_SESSION_TICKETS
+        help
+            The url of the server to which the example is going to connect in order to test the session ticket support.
+
+    config EXAMPLE_LOCAL_SERVER_URL_FROM_STDIN
+        bool
+        default y if EXAMPLE_LOCAL_SERVER_URL = "FROM_STDIN"
+
+endmenu

examples/protocols/https_request/main/https_request_example_main.c

@@ -53,15 +53,24 @@
 #define WEB_PORT "443"
 #define WEB_URL "https://www.howsmyssl.com/a/check"
 
+#define SERVER_URL_MAX_SZ 256
+
 static const char *TAG = "example";
 
 /* Timer interval once every day (24 Hours) */
 #define TIME_PERIOD (86400000000ULL)
 
-static const char REQUEST[] = "GET " WEB_URL " HTTP/1.1\r\n"
+static const char HOWSMYSSL_REQUEST[] = "GET " WEB_URL " HTTP/1.1\r\n"
+                             "Host: "WEB_SERVER"\r\n"
+                             "User-Agent: esp-idf/1.0 esp32\r\n"
+                             "\r\n";
+
+#ifdef CONFIG_EXAMPLE_CLIENT_SESSION_TICKETS
+static const char LOCAL_SRV_REQUEST[] = "GET " CONFIG_EXAMPLE_LOCAL_SERVER_URL " HTTP/1.1\r\n"
                              "Host: "WEB_SERVER"\r\n"
                              "User-Agent: esp-idf/1.0 esp32\r\n"
                              "\r\n";
+#endif
 
 /* Root cert for howsmyssl.com, taken from server_root_cert.pem
 
@@ -75,15 +84,21 @@ static const char REQUEST[] = "GET " WEB_URL " HTTP/1.1\r\n"
 */
 extern const uint8_t server_root_cert_pem_start[] asm("_binary_server_root_cert_pem_start");
 extern const uint8_t server_root_cert_pem_end[]   asm("_binary_server_root_cert_pem_end");
-#ifdef CONFIG_ESP_TLS_CLIENT_SESSION_TICKETS
+
+extern const uint8_t local_server_cert_pem_start[] asm("_binary_local_server_cert_pem_start");
+extern const uint8_t local_server_cert_pem_end[]   asm("_binary_local_server_cert_pem_end");
+
+#ifdef CONFIG_EXAMPLE_CLIENT_SESSION_TICKETS
 esp_tls_client_session_t *tls_client_session = NULL;
+static bool save_client_session = false;
 #endif
-static void https_get_request(esp_tls_cfg_t cfg)
+
+static void https_get_request(esp_tls_cfg_t cfg, const char *WEB_SERVER_URL, const char *REQUEST)
 {
     char buf[512];
     int ret, len;
 
-    struct esp_tls *tls = esp_tls_conn_http_new(WEB_URL, &cfg);
+    struct esp_tls *tls = esp_tls_conn_http_new(WEB_SERVER_URL, &cfg);
 
     if (tls != NULL) {
         ESP_LOGI(TAG, "Connection established...");
@@ -92,9 +107,10 @@ static void https_get_request(esp_tls_cfg_t cfg)
         goto exit;
     }
 
-#ifdef CONFIG_ESP_TLS_CLIENT_SESSION_TICKETS
+#ifdef CONFIG_EXAMPLE_CLIENT_SESSION_TICKETS
     /* The TLS session is successfully established, now saving the session ctx for reuse */
-    if (tls_client_session == NULL) {
+    if (save_client_session) {
+        free(tls_client_session);
         tls_client_session = esp_tls_get_client_session(tls);
     }
 #endif
@@ -102,7 +118,7 @@ static void https_get_request(esp_tls_cfg_t cfg)
     do {
         ret = esp_tls_conn_write(tls,
                                  REQUEST + written_bytes,
-                                 sizeof(REQUEST) - written_bytes);
+                                 strlen(REQUEST) - written_bytes);
         if (ret >= 0) {
             ESP_LOGI(TAG, "%d bytes written", ret);
             written_bytes += ret;
@@ -110,7 +126,7 @@ static void https_get_request(esp_tls_cfg_t cfg)
             ESP_LOGE(TAG, "esp_tls_conn_write  returned: [0x%02X](%s)", ret, esp_err_to_name(ret));
             goto exit;
         }
-    } while (written_bytes < sizeof(REQUEST));
+    } while (written_bytes < strlen(REQUEST));
 
     ESP_LOGI(TAG, "Reading HTTP response...");
 
@@ -156,7 +172,7 @@ static void https_get_request_using_crt_bundle(void)
     esp_tls_cfg_t cfg = {
         .crt_bundle_attach = esp_crt_bundle_attach,
     };
-    https_get_request(cfg);
+    https_get_request(cfg, WEB_URL, HOWSMYSSL_REQUEST);
 }
 
 
@@ -168,7 +184,7 @@ static void https_get_request_using_cacert_buf(void)
         .cacert_buf = (const unsigned char *) server_root_cert_pem_start,
         .cacert_bytes = server_root_cert_pem_end - server_root_cert_pem_start,
     };
-    https_get_request(cfg);
+    https_get_request(cfg, WEB_URL, HOWSMYSSL_REQUEST);
 }
 
 static void https_get_request_using_global_ca_store(void)
@@ -183,19 +199,32 @@ static void https_get_request_using_global_ca_store(void)
     esp_tls_cfg_t cfg = {
         .use_global_ca_store = true,
     };
-    https_get_request(cfg);
+    https_get_request(cfg, WEB_URL, HOWSMYSSL_REQUEST);
     esp_tls_free_global_ca_store();
 }
 
-#ifdef CONFIG_ESP_TLS_CLIENT_SESSION_TICKETS
-static void https_get_request_using_already_saved_session(void)
+#ifdef CONFIG_EXAMPLE_CLIENT_SESSION_TICKETS
+static void https_get_request_to_local_server(const char* url)
+{
+    ESP_LOGI(TAG, "https_request to local server");
+    esp_tls_cfg_t cfg = {
+        .cacert_buf = (const unsigned char *) local_server_cert_pem_start,
+        .cacert_bytes = local_server_cert_pem_end - local_server_cert_pem_start,
+        .skip_common_name = true,
+    };
+    save_client_session = true;
+    https_get_request(cfg, url, LOCAL_SRV_REQUEST);
+}
+
+static void https_get_request_using_already_saved_session(const char *url)
 {
     ESP_LOGI(TAG, "https_request using saved client session");
     esp_tls_cfg_t cfg = {
         .client_session = tls_client_session,
     };
-    https_get_request(cfg);
+    https_get_request(cfg, url, LOCAL_SRV_REQUEST);
     free(tls_client_session);
+    save_client_session = false;
     tls_client_session = NULL;
 }
 #endif
@@ -204,12 +233,32 @@ static void https_request_task(void *pvparameters)
 {
     ESP_LOGI(TAG, "Start https_request example");
 
+#ifdef CONFIG_EXAMPLE_CLIENT_SESSION_TICKETS
+    char *server_url = NULL;
+#ifdef CONFIG_EXAMPLE_LOCAL_SERVER_URL_FROM_STDIN
+    char url_buf[SERVER_URL_MAX_SZ];
+    if (strcmp(CONFIG_EXAMPLE_LOCAL_SERVER_URL, "FROM_STDIN") == 0) {
+        example_configure_stdin_stdout();
+        fgets(url_buf, SERVER_URL_MAX_SZ, stdin);
+        int len = strlen(url_buf);
+        url_buf[len - 1] = '\0';
+        server_url = url_buf;
+    } else {
+        ESP_LOGE(TAG, "Configuration mismatch: invalid url for local server");
+        abort();
+    }
+    printf("\nServer URL obtained is %s\n", url_buf);
+#else
+    server_url = CONFIG_EXAMPLE_LOCAL_SERVER_URL;
+#endif /* CONFIG_EXAMPLE_LOCAL_SERVER_URL_FROM_STDIN */
+    https_get_request_to_local_server(server_url);
+    https_get_request_using_already_saved_session(server_url);
+#endif
+
     https_get_request_using_crt_bundle();
+    printf("Minimum free heap size: %d bytes\n", esp_get_minimum_free_heap_size());
     https_get_request_using_cacert_buf();
     https_get_request_using_global_ca_store();
-#ifdef CONFIG_ESP_TLS_CLIENT_SESSION_TICKETS
-    https_get_request_using_already_saved_session();
-#endif
     ESP_LOGI(TAG, "Finish https_request example");
     vTaskDelete(NULL);
 }

examples/protocols/https_request/main/local_server_cert.pem

@@ -0,0 +1,17 @@
+-----BEGIN CERTIFICATE-----
+MIICyDCCAbACCQC4RVDDRrCbrDANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBtF
+U1AzMiBIVFRQUyByZXF1ZXN0IGV4YW1wbGUwHhcNMjExMTE0MjAxMjQ4WhcNMzEx
+MTEyMjAxMjQ4WjAmMSQwIgYDVQQDDBtFU1AzMiBIVFRQUyByZXF1ZXN0IGV4YW1w
+bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9eiUPHf31rkkTQ7Pq
+EHeefT5pC8VZvfpgQSOz4nQNvX94BysC+Ycv0MTnWn2yKk4fj/gXaf3mhlcmNwZO
+CGMIgi9BzACWgOKAlUMXwbo3qOdMXRPgWvv/vv6xM5WdVjWPdC/LJOg41wqYblZ7
+FTZhxw5K7wLkjiAZrWcm4bd993Z0Hy7WXWFMaBURjPehORq/E2GeL11o+aLGT/Fi
+0c64gBsyiGt+RK5c/QkoS44WM77YwiUbzuKdLd5j4LXNcqc47Ac1oPl7vTSUQta+
+4Ixaler/IC8yg9l2f9t1HsYNfL/6O61C1PoHSqwWwMU1eegdW33UYGrA00NSfSNI
+7k8XAgMBAAEwDQYJKoZIhvcNAQELBQADggEBADqDXuXa90kwJGmbjyNMgmBdsCvg
+0Z+bG085hjKY/TogH76E8bhbN0obXxIbht4LKNdrC76IIE/iY/EF+LRBiWCemUHV
+Pgj16REG335R86VU9UTSoGte1oOK3ttmJ10bz1WeBSTOT21OyTqvI0+zWvei9Jel
+ADDGck47sJoAbDv2FC6AhFjkmG0YsaoJtXsSAnKmLL+qsJ1z0ZIHxupIO7coG2fe
+6ZZMWnLt5ODCopYCY6aVuODoJ4Ywe+Yu3tBPG7AF9em7MfUVngOJCGUrhu4RLCTm
+3FT53VgKyMjQKVzeg9hkRvgePWX4oByWCmxzvWAV5oavh41BvpRsW4vBF54=
+-----END CERTIFICATE-----

examples/protocols/https_request/main/local_server_key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC9eiUPHf31rkkT
+Q7PqEHeefT5pC8VZvfpgQSOz4nQNvX94BysC+Ycv0MTnWn2yKk4fj/gXaf3mhlcm
+NwZOCGMIgi9BzACWgOKAlUMXwbo3qOdMXRPgWvv/vv6xM5WdVjWPdC/LJOg41wqY
+blZ7FTZhxw5K7wLkjiAZrWcm4bd993Z0Hy7WXWFMaBURjPehORq/E2GeL11o+aLG
+T/Fi0c64gBsyiGt+RK5c/QkoS44WM77YwiUbzuKdLd5j4LXNcqc47Ac1oPl7vTSU
+Qta+4Ixaler/IC8yg9l2f9t1HsYNfL/6O61C1PoHSqwWwMU1eegdW33UYGrA00NS
+fSNI7k8XAgMBAAECggEADa5QFrNXrvGSnS16RCBEQtFQPE15Rm2NMn4Bke976bIR
+Dh2WYXSa6jzsurex87dSRL0kcKxahNaWXFAEyIWagPbFar7MHBHaSOZ+Ha0DQRmU
++dKOqNho8aJcyXasCtw6qcz91nEnw1LjlPYCkIiLkKvKwGZZkx8f+jqnBAuwMAwa
+VZzrtDw2zZAZXBspC9n9fa0IAY4rq7QWCl/HlTEody8VuLng7+WEhFJRJ0F1IK9v
+U1NihTdZRuybWQvmcj3fh+44PHBNkljoPPwN361eNR9aYiU/KtTIa8En+ZQPyetH
+rmr6rMsd7rBTTbPch6nanN5rsmWCMbQj3bD6LWuEQQKBgQDg50fMK2XQfZukPDjT
+3rYBPCSKUdE8uzP5p2xurHLZa+zjrhkVu3895OaP4WHYNAOaaTMnxwTVY2xXMA/F
+uoJmDpVzuDjgp1qjqDK96XMPSUs30dwI8LgYCfEm7gKZ7BFSn8QlhxeFIn4fhxwS
+w6vBeNp0uL9Pjj/C2ZCDd6iWCQKBgQDXrOigR22OHWksAeDz/TVW/KEQEkFHvuF7
+U87YyV+771TYT98fkKZ4zyStIK96eWumxmeBTVSg5zS+8aOFfWO3OL4Bfj45JWaJ
+rblh/bgLUsa5J6jrm9ISVATfqN3GiEJw8LhkCjIqI269ku874jQrCifZPVKFffkf
+2/1LSswEHwKBgQDU4PYrwnQ32X0GAt7DZM4f8x6fMnx8ILI8wAW56E85j5eFlxg1
+Yuk4276FOA+WRv2WHbeHEjF4DgjRqjNztGuTUICULS7hLmdz+1Q0QJFhSb4B0wmU
+CM4oKtjxQV6C9VkcPQ+7ediAczqwewHOnRmpIsycqPakxf+CXs8UMaIIiQKBgA8F
+30pSz2HH0KydEONN7uo5PKrW6q8pr6EcjFrzY/S+TgWnQp57P+1IWICqty5ryMDc
+LxeFoHB4ymbGhCJnQovfqvSFq6XlYggTDsexmaFISclZ5t1KhE58hb5ij9glY6Nk
+USO+xhHDWBJiasGcFxAsa+wo5legF7tNYo5dDmr3AoGAQ+i2gtXpZELQZ9ODkIbR
+wlvRTlElDkk/+a9O/k18eFv4uyw4locngsWtz6lpzJuXikj+LtnYKMInvZxwmyJT
+n4MLb/SNxpaumZHhSZy5xU1x7RgBzR/NyaJIws70eDvc6g9PIe2ahVoDDMSZxtGN
+3tplBVJpwQuwwoKFmE2ea9I=
+-----END PRIVATE KEY-----

examples/protocols/https_request/sdkconfig.ci.cli_ses_tkt

@@ -0,0 +1,12 @@
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+CONFIG_EXAMPLE_CONNECT_IPV6=y
+CONFIG_EXAMPLE_CLIENT_SESSION_TICKETS=y
+CONFIG_EXAMPLE_LOCAL_SERVER_URL="FROM_STDIN"
+CONFIG_EXAMPLE_LOCAL_SERVER_URL_FROM_STDIN=y

examples/protocols/https_request/sdkconfig.defaults

@@ -1,2 +1 @@
-CONFIG_ESP_TLS_CLIENT_SESSION_TICKETS=y
 CONFIG_MBEDTLS_HAVE_TIME_DATE=y