Merge branch 'Jason2866:release/v5.2' into release/v5.2

Author: Jason2866

components/bt/esp_ble_mesh/core/net.c

@@ -2,7 +2,7 @@
 
 /*
  * SPDX-FileCopyrightText: 2017 Intel Corporation
- * SPDX-FileContributor: 2018-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileContributor: 2018-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -1129,23 +1129,34 @@ int bt_mesh_net_send(struct bt_mesh_net_tx *tx, struct net_buf *buf,
     if (((IS_ENABLED(CONFIG_BLE_MESH_NODE) && bt_mesh_is_provisioned()) ||
          (IS_ENABLED(CONFIG_BLE_MESH_PROVISIONER) && bt_mesh_is_provisioner_en())) &&
         (bt_mesh_fixed_group_match(tx->ctx->addr) || bt_mesh_elem_find(tx->ctx->addr))) {
-        if (cb && cb->start) {
-            cb->start(0, 0, cb_data);
-        }
+        /**
+         * If the target address isn't a unicast address, then the callback function
+         * will be called by `adv task` in place of here, to avoid the callback function
+         * being called twice.
+         * See BLEMESH24-76 for more details.
+         */
+        if (BLE_MESH_ADDR_IS_UNICAST(tx->ctx->addr)) {
+            if (cb && cb->start) {
+                cb->start(0, 0, cb_data);
+            }
 
-        net_buf_slist_put(&bt_mesh.local_queue, net_buf_ref(buf));
+            net_buf_slist_put(&bt_mesh.local_queue, net_buf_ref(buf));
 
-        if (cb && cb->end) {
-            cb->end(0, cb_data);
-        }
+            if (cb && cb->end) {
+                cb->end(0, cb_data);
+            }
 
-        bt_mesh_net_local();
+            bt_mesh_net_local();
+
+            err = 0;
 
-        err = 0;
-        /* If it is a group address, it still needs to be relayed */
-        if (BLE_MESH_ADDR_IS_UNICAST(tx->ctx->addr)) {
             goto done;
+        } else {
+            net_buf_slist_put(&bt_mesh.local_queue, net_buf_ref(buf));
+            bt_mesh_net_local();
         }
+
+        err = 0;
     }
 
     if ((bearer & BLE_MESH_ADV_BEARER) &&

components/esp_wifi/include/esp_wifi_types.h

@@ -961,6 +961,7 @@ typedef struct {
 typedef enum {
     WPS_FAIL_REASON_NORMAL = 0,     /**< WPS normal fail reason */
     WPS_FAIL_REASON_RECV_M2D,       /**< WPS receive M2D frame */
+    WPS_FAIL_REASON_RECV_DEAUTH,    /**< Recv deauth from AP while wps handshake */
     WPS_FAIL_REASON_MAX
 } wifi_event_sta_wps_fail_reason_t;
 

components/esp_wifi/lib

@@ -45,9 +45,10 @@ static esp_err_t lp_i2c_gpio_is_cfg_valid(gpio_num_t sda_io_num, gpio_num_t scl_
 
 static esp_err_t lp_i2c_configure_io(gpio_num_t io_num, bool pullup_en)
 {
+    /* Set the IO pin to high to avoid them from toggling from Low to High state during initialization. This can register a spurious I2C start condition. */
+    ESP_RETURN_ON_ERROR(rtc_gpio_set_level(io_num, 1), LPI2C_TAG, "LP GPIO failed to set level to high for %d", io_num);
     /* Initialize IO Pin */
     ESP_RETURN_ON_ERROR(rtc_gpio_init(io_num), LPI2C_TAG, "LP GPIO Init failed for GPIO %d", io_num);
-
     /* Set direction to input+output open-drain mode */
     ESP_RETURN_ON_ERROR(rtc_gpio_set_direction(io_num, RTC_GPIO_MODE_INPUT_OUTPUT_OD), LPI2C_TAG, "LP GPIO Set direction failed for %d", io_num);
     /* Disable pulldown on the io pin */
@@ -72,12 +73,16 @@ static esp_err_t lp_i2c_set_pin(const lp_core_i2c_cfg_t *cfg)
     /* Verify that the LP I2C GPIOs are valid */
     ESP_RETURN_ON_ERROR(lp_i2c_gpio_is_cfg_valid(sda_io_num, scl_io_num), LPI2C_TAG, "LP I2C GPIO config invalid");
 
-    /* Initialize SDA Pin */
-    ESP_RETURN_ON_ERROR(lp_i2c_configure_io(sda_io_num, sda_pullup_en), LPI2C_TAG, "LP I2C SDA pin config failed");
+    // NOTE: We always initialize the SCL pin first, then the SDA pin.
+    // This order of initialization is important to avoid any spurious
+    // I2C start conditions on the bus.
 
     /* Initialize SCL Pin */
     ESP_RETURN_ON_ERROR(lp_i2c_configure_io(scl_io_num, scl_pullup_en), LPI2C_TAG, "LP I2C SCL pin config failed");
 
+    /* Initialize SDA Pin */
+    ESP_RETURN_ON_ERROR(lp_i2c_configure_io(sda_io_num, sda_pullup_en), LPI2C_TAG, "LP I2C SDA pin config failed");
+
     /* Select LP I2C function for the SDA Pin */
     lp_io_dev->gpio[sda_io_num].mcu_sel = 1;
 
@@ -103,7 +108,7 @@ static esp_err_t lp_i2c_config_clk(const lp_core_i2c_cfg_t *cfg)
         }
     }
 
-    /* Fetch the clock source fequency */
+    /* Fetch the clock source frequency */
     ESP_RETURN_ON_ERROR(esp_clk_tree_src_get_freq_hz(source_clk, ESP_CLK_TREE_SRC_FREQ_PRECISION_APPROX, &source_freq), LPI2C_TAG, "Invalid LP I2C source clock selected");
 
     /* Verify that the I2C_SCLK operates at a frequency 20 times larger than the requested SCL bus frequency */
@@ -141,6 +146,9 @@ esp_err_t lp_core_i2c_master_init(i2c_port_t lp_i2c_num, const lp_core_i2c_cfg_t
     /* Initialize LP I2C HAL */
     i2c_hal_init(&i2c_hal, lp_i2c_num);
 
+    /* Clear any pending interrupts */
+    i2c_ll_clear_intr_mask(i2c_hal.dev, UINT32_MAX);
+
     /* Initialize LP I2C Master mode */
     i2c_hal_master_init(&i2c_hal);
 

components/ulp/lp_core/lp_core_i2c.c

@@ -72,6 +72,8 @@ static esp_err_t i2c_gpio_is_cfg_valid(gpio_num_t sda_io_num, gpio_num_t scl_io_
 
 static esp_err_t i2c_configure_io(gpio_num_t io_num, bool pullup_en)
 {
+    /* Set the IO pin to high to avoid them from toggling from Low to High state during initialization. This can register a spurious I2C start condition. */
+    ESP_RETURN_ON_ERROR(rtc_gpio_set_level(io_num, 1), RTCI2C_TAG, "RTC GPIO failed to set level to high for %d", io_num);
     /* Initialize IO Pin */
     ESP_RETURN_ON_ERROR(rtc_gpio_init(io_num), RTCI2C_TAG, "RTC GPIO Init failed for GPIO %d", io_num);
     /* Set direction to input+output */
@@ -98,12 +100,16 @@ static esp_err_t i2c_set_pin(const ulp_riscv_i2c_cfg_t *cfg)
     /* Verify that the I2C GPIOs are valid */
     ESP_RETURN_ON_ERROR(i2c_gpio_is_cfg_valid(sda_io_num, scl_io_num), RTCI2C_TAG, "RTC I2C GPIO config invalid");
 
-    /* Initialize SDA Pin */
-    ESP_RETURN_ON_ERROR(i2c_configure_io(sda_io_num, sda_pullup_en), RTCI2C_TAG, "RTC I2C SDA pin config failed");
+    // NOTE: We always initialize the SCL pin first, then the SDA pin.
+    // This order of initialization is important to avoid any spurious
+    // I2C start conditions on the bus.
 
     /* Initialize SCL Pin */
     ESP_RETURN_ON_ERROR(i2c_configure_io(scl_io_num, scl_pullup_en), RTCI2C_TAG, "RTC I2C SCL pin config failed");
 
+    /* Initialize SDA Pin */
+    ESP_RETURN_ON_ERROR(i2c_configure_io(sda_io_num, sda_pullup_en), RTCI2C_TAG, "RTC I2C SDA pin config failed");
+
     /* Route SDA IO signal to the RTC subsystem */
     rtc_io_dev->touch_pad[sda_io_num].mux_sel = 1;
 
@@ -471,6 +477,12 @@ esp_err_t ulp_riscv_i2c_master_init(const ulp_riscv_i2c_cfg_t *cfg)
     WRITE_PERI_REG(RTC_I2C_CTRL_REG, 0);
     WRITE_PERI_REG(SENS_SAR_I2C_CTRL_REG, 0);
 
+    /* Verify that the input cfg param is valid */
+    ESP_RETURN_ON_FALSE(cfg, ESP_ERR_INVALID_ARG, RTCI2C_TAG, "RTC I2C configuration is NULL");
+
+    /* Configure RTC I2C GPIOs */
+    ESP_RETURN_ON_ERROR(i2c_set_pin(cfg), RTCI2C_TAG, "Failed to configure RTC I2C GPIOs");
+
     /* Reset RTC I2C */
 #if CONFIG_IDF_TARGET_ESP32S2
     i2c_dev->ctrl.i2c_reset = 1;
@@ -484,12 +496,6 @@ esp_err_t ulp_riscv_i2c_master_init(const ulp_riscv_i2c_cfg_t *cfg)
     CLEAR_PERI_REG_MASK(SENS_SAR_PERI_RESET_CONF_REG, SENS_RTC_I2C_RESET);
 #endif // CONFIG_IDF_TARGET_ESP32S2
 
-    /* Verify that the input cfg param is valid */
-    ESP_RETURN_ON_FALSE(cfg, ESP_ERR_INVALID_ARG, RTCI2C_TAG, "RTC I2C configuration is NULL");
-
-    /* Configure RTC I2C GPIOs */
-    ESP_RETURN_ON_ERROR(i2c_set_pin(cfg), RTCI2C_TAG, "Failed to configure RTC I2C GPIOs");
-
     /* Enable internal open-drain mode for SDA and SCL lines */
 #if CONFIG_IDF_TARGET_ESP32S2
     i2c_dev->ctrl.sda_force_out = 0;
@@ -519,6 +525,9 @@ esp_err_t ulp_riscv_i2c_master_init(const ulp_riscv_i2c_cfg_t *cfg)
     /* Configure RTC I2C timing parameters */
     ESP_RETURN_ON_ERROR(i2c_set_timing(cfg), RTCI2C_TAG, "Failed to configure RTC I2C timing");
 
+    /* Clear any pending interrupts */
+    WRITE_PERI_REG(RTC_I2C_INT_CLR_REG, UINT32_MAX);
+
     /* Enable RTC I2C interrupts */
     SET_PERI_REG_MASK(RTC_I2C_INT_ENA_REG, RTC_I2C_RX_DATA_INT_ENA |
                                            RTC_I2C_TX_DATA_INT_ENA |

components/ulp/ulp_riscv/ulp_riscv_i2c.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -26,7 +26,8 @@
 #include "mbedtls/error.h"
 #include "mbedtls/oid.h"
 
-#define ECP_PRV_DER_MAX_BYTES   29 + 3 * MBEDTLS_ECP_MAX_BYTES
+#define ECP_PRV_DER_MAX_BYTES   ( 29 + 3 * MBEDTLS_ECP_MAX_BYTES )
+#define ECP_PUB_DER_MAX_BYTES   ( 30 + 2 * MBEDTLS_ECP_MAX_BYTES )
 
 #ifdef CONFIG_MBEDTLS_ECDH_LEGACY_CONTEXT
 #define ACCESS_ECDH(S, var) S->MBEDTLS_PRIVATE(var)
@@ -518,6 +519,7 @@ struct crypto_key * crypto_ec_set_pubkey_point(const struct crypto_ec_group *gro
 	struct crypto_key *pkey = NULL;
 	int ret;
 	mbedtls_pk_context *key = (mbedtls_pk_context *)crypto_alloc_key();
+	mbedtls_ecp_group *ecp_grp = (mbedtls_ecp_group *)group;
 
 	if (!key) {
 		wpa_printf(MSG_ERROR, "%s: memory allocation failed", __func__);
@@ -538,7 +540,7 @@ struct crypto_key * crypto_ec_set_pubkey_point(const struct crypto_ec_group *gro
 		goto fail;
 	}
 
-	if (mbedtls_ecp_check_pubkey((mbedtls_ecp_group *)group, point) < 0) { //typecast
+	if (mbedtls_ecp_check_pubkey(ecp_grp, point) < 0) {
 		// ideally should have failed in upper condition, duplicate code??
 		wpa_printf(MSG_ERROR, "Invalid key");
 		goto fail;
@@ -547,8 +549,9 @@ struct crypto_key * crypto_ec_set_pubkey_point(const struct crypto_ec_group *gro
 	if( ( ret = mbedtls_pk_setup( key,
 					mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY) ) ) != 0 )
 		goto fail;
+
 	mbedtls_ecp_copy(&mbedtls_pk_ec(*key)->MBEDTLS_PRIVATE(Q), point);
-	mbedtls_ecp_group_load(&mbedtls_pk_ec(*key)->MBEDTLS_PRIVATE(grp), MBEDTLS_ECP_DP_SECP256R1);
+	mbedtls_ecp_group_load(&mbedtls_pk_ec(*key)->MBEDTLS_PRIVATE(grp), ecp_grp->id);
 
 	pkey = (struct crypto_key *)key;
 	crypto_ec_point_deinit((struct crypto_ec_point *)point, 0);
@@ -581,19 +584,27 @@ struct crypto_ec_point *crypto_ec_get_public_key(struct crypto_key *key)
 int crypto_ec_get_priv_key_der(struct crypto_key *key, unsigned char **key_data, int *key_len)
 {
 	mbedtls_pk_context *pkey = (mbedtls_pk_context *)key;
-	char der_data[ECP_PRV_DER_MAX_BYTES];
+	char *der_data = os_malloc(ECP_PRV_DER_MAX_BYTES);
 
+	if (!der_data) {
+		wpa_printf(MSG_ERROR, "memory allocation failed");
+		return -1;
+	}
 	*key_len = mbedtls_pk_write_key_der(pkey, (unsigned char *)der_data, ECP_PRV_DER_MAX_BYTES);
-	if (*key_len <= 0)
+	if (*key_len <= 0) {
+		wpa_printf(MSG_ERROR, "Failed to write priv key");
+		os_free(der_data);
 		return -1;
-
+	}
 	*key_data = os_malloc(*key_len);
 
 	if (!*key_data) {
 		wpa_printf(MSG_ERROR, "memory allocation failed");
+		os_free(der_data);
 		return -1;
 	}
-	os_memcpy(*key_data, der_data, *key_len);
+	os_memcpy(*key_data, der_data + ECP_PRV_DER_MAX_BYTES - *key_len, *key_len);
+	os_free(der_data);
 
 	return 0;
 }
@@ -643,16 +654,25 @@ int crypto_ec_get_publickey_buf(struct crypto_key *key, u8 *key_buf, int len)
 
 int crypto_write_pubkey_der(struct crypto_key *key, unsigned char **key_buf)
 {
-	unsigned char output_buf[1600] = {0};
-	int len = mbedtls_pk_write_pubkey_der((mbedtls_pk_context *)key, output_buf, 1600);
-	if (len <= 0)
-		return 0;
+	unsigned char *buf = os_malloc(ECP_PUB_DER_MAX_BYTES);
+
+	if(!buf) {
+		wpa_printf(MSG_ERROR, "memory allocation failed");
+		return -1;
+	}
+	int len = mbedtls_pk_write_pubkey_der((mbedtls_pk_context *)key, buf, ECP_PUB_DER_MAX_BYTES);
+	if (len <= 0) {
+		os_free(buf);
+		return -1;
+	}
 
 	*key_buf = os_malloc(len);
 	if (!*key_buf) {
-		return 0;
+		os_free(buf);
+		return -1;
 	}
-	os_memcpy(*key_buf, output_buf + 1600 - len, len);
+	os_memcpy(*key_buf, buf + ECP_PUB_DER_MAX_BYTES - len, len);
+	os_free(buf);
 
 	return len;
 }
@@ -812,28 +832,21 @@ int crypto_ecdsa_get_sign(unsigned char *hash,
 int crypto_edcsa_sign_verify(const unsigned char *hash,
 		const struct crypto_bignum *r, const struct crypto_bignum *s, struct crypto_key *csign, int hlen)
 {
-	mbedtls_pk_context *pkey = (mbedtls_pk_context *)csign;
-	int ret = 0;
-
-	mbedtls_ecdsa_context *ctx = os_malloc(sizeof(*ctx));
-	if (!ctx) {
-		wpa_printf(MSG_ERROR, "failed to allcate memory");
-		return ret;
+	/* (mbedtls_ecdsa_context *) */
+        mbedtls_ecp_keypair *ecp_kp = mbedtls_pk_ec(*(mbedtls_pk_context *)csign);
+        if (!ecp_kp) {
+                return -1;
 	}
-	mbedtls_ecdsa_init(ctx);
-
-	if (mbedtls_ecdsa_from_keypair(ctx, mbedtls_pk_ec(*pkey)) < 0)
-		return ret;
 
-	if((ret = mbedtls_ecdsa_verify(&ctx->MBEDTLS_PRIVATE(grp), hash, hlen,
-					&ctx->MBEDTLS_PRIVATE(Q), (mbedtls_mpi *)r, (mbedtls_mpi *)s)) != 0){
+        mbedtls_ecp_group *ecp_kp_grp = &ecp_kp->MBEDTLS_PRIVATE(grp);
+        mbedtls_ecp_point *ecp_kp_q = &ecp_kp->MBEDTLS_PRIVATE(Q);
+        int ret = mbedtls_ecdsa_verify(ecp_kp_grp, hash, hlen,
+                                       ecp_kp_q, (mbedtls_mpi *)r, (mbedtls_mpi *)s);
+        if (ret != 0) {
 		wpa_printf(MSG_ERROR, "ecdsa verification failed");
 		return ret;
 	}
 
-	mbedtls_ecdsa_free(ctx);
-	os_free(ctx);
-
 	return ret;
 }
 
@@ -861,14 +874,18 @@ struct crypto_key *crypto_ec_parse_subpub_key(const unsigned char *p, size_t len
 {
 	int ret;
 	mbedtls_pk_context *pkey = (mbedtls_pk_context *)crypto_alloc_key();
-	ret = mbedtls_pk_parse_subpubkey((unsigned char **)&p, p + len, pkey);
 
-	if (ret < 0) {
-		os_free(pkey);
+	if (!pkey) {
 		return NULL;
 	}
+	ret = mbedtls_pk_parse_subpubkey((unsigned char **)&p, p + len, pkey);
+	if (ret == 0) {
+		return (struct crypto_key *)pkey;
+	}
 
-	return (struct crypto_key *)pkey;
+	mbedtls_pk_free(pkey);
+	os_free(pkey);
+	return NULL;
 }
 
 int crypto_is_ec_key(struct crypto_key *key)