alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Merge branch 'fix/https_request_example_test' into 'master'

Browse Source 
https_request_example: Update the example test to use local python server

See merge request espressif/esp-idf!15931
This commit is contained in:
Aditya Patwardhan 2021-12-07 11:14:34 +00:00
commit c66c18596c
8 changed files with 329 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
examples/protocols/https_request/example_test.py
View File

@ -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()

2
examples/protocols/https_request/main/CMakeLists.txt
View File

@ -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)

21
examples/protocols/https_request/main/Kconfig.projbuild Normal file
View File

@ -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

83
examples/protocols/https_request/main/https_request_example_main.c
View File

@ -53,16 +53,25 @@
#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
The PEM file was extracted from the output of this command:
@ -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);
}

17
examples/protocols/https_request/main/local_server_cert.pem Normal file
View File

@ -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-----

28
examples/protocols/https_request/main/local_server_key.pem Normal file
View File

@ -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-----

12
examples/protocols/https_request/sdkconfig.ci.cli_ses_tkt Normal file
View File

@ -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

1
examples/protocols/https_request/sdkconfig.defaults
View File

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