diff --git a/wolfcrypt/src/port/Espressif/esp32_sha.c b/wolfcrypt/src/port/Espressif/esp32_sha.c
index 6722a9308..474a0c571 100644
--- a/wolfcrypt/src/port/Espressif/esp32_sha.c
+++ b/wolfcrypt/src/port/Espressif/esp32_sha.c
@@ -1311,7 +1311,8 @@ int esp_sha_try_hw_lock(WC_ESP32SHA* ctx)
         }
     }
 
-#ifdef ESP_MONITOR_HW_TASK_LOCK
+#if defined(ESP_MONITOR_HW_TASK_LOCK) || \
+   (defined(WOLFSSL_DEBUG_MUTEX) && WOLFSSL_DEBUG_MUTEX)
     /* Nothing happening here other than messages based on mutex states */
     if (mutex_ctx_task == 0 || mutex_ctx_owner == 0) {
         /* no known stray mutex task owner */
@@ -1347,13 +1348,15 @@ int esp_sha_try_hw_lock(WC_ESP32SHA* ctx)
             } /* mutex owner ESP32_SHA_FREED check */
         } /* mutex_ctx_task is current task */
         else {
+#ifdef WOLFSSL_ESP32_HW_LOCK_DEBUG
             ESP_LOGW(TAG, "Warning: sha mutex unlock from unexpected task.");
             ESP_LOGW(TAG, "Locking task: 0x%x", (word32)mutex_ctx_task);
             ESP_LOGW(TAG, "This xTaskGetCurrentTaskHandle: 0x%x",
                           (word32)xTaskGetCurrentTaskHandle());
+#endif
         }
     }
-#endif /* ESP_MONITOR_HW_TASK_LOCK */
+#endif /* ESP_MONITOR_HW_TASK_LOCK || WOLFSSL_DEBUG_MUTEX */
 
     /* check if this SHA has been operated as SW or HW, or not yet init */
     if (ctx->mode == ESP32_SHA_INIT) {
diff --git a/wolfcrypt/src/port/Espressif/esp_sdk_mem_lib.c b/wolfcrypt/src/port/Espressif/esp_sdk_mem_lib.c
index d1e51a5f0..727a12f89 100644
--- a/wolfcrypt/src/port/Espressif/esp_sdk_mem_lib.c
+++ b/wolfcrypt/src/port/Espressif/esp_sdk_mem_lib.c
@@ -189,7 +189,8 @@ int sdk_log_meminfo(enum sdk_memory_segment m, void* start, void* end)
 }
 
 /* Show all known linker memory segment names, starting & ending addresses. */
-int sdk_init_meminfo(void) {
+int sdk_init_meminfo(void)
+{
     void* sample_heap_var;
     int sample_stack_var = 0;
 
@@ -241,7 +242,8 @@ int sdk_init_meminfo(void) {
 }
 
 /* Returns ESP_OK if found in known memory map, ESP_FAIL otherwise */
-esp_err_t sdk_var_whereis(const char* v_name, void* v) {
+esp_err_t sdk_var_whereis(const char* v_name, void* v)
+{
     esp_err_t ret = ESP_FAIL;
 
     for (enum sdk_memory_segment m = 0 ;m < SDK_MEMORY_SEGMENT_COUNT; m++) {
@@ -289,15 +291,110 @@ esp_err_t esp_sdk_mem_lib_init(void)
     return ret;
 }
 
+#if defined(DEBUG_WOLFSSL_MALLOC) || defined(DEBUG_WOLFSSL)
 void* wc_debug_pvPortMalloc(size_t size,
-                           const char* file, int line, const char* fname) {
+                           const char* file, int line, const char* fname)
+#else
+void* wc_pvPortMalloc(size_t size)
+#endif
+{
     void* ret = NULL;
-    ret = pvPortMalloc(size);
+    wolfSSL_Malloc_cb  mc;
+    wolfSSL_Free_cb    fc;
+    wolfSSL_Realloc_cb rc;
+    wolfSSL_GetAllocators(&mc, &fc, &rc);
+
+    if (mc == NULL) {
+        ret = pvPortMalloc(size);
+    }
+    else {
+#if defined(USE_WOLFSSL_MEMORY) && !defined(NO_WOLFSSL_MEMORY)
+        ret = mc(size);
+#else
+        ret = pvPortMalloc(size);
+#endif
+    }
+
+#if defined(DEBUG_WOLFSSL_MALLOC) || defined(DEBUG_WOLFSSL)
     if (ret == NULL) {
         ESP_LOGE("malloc", "%s:%d (%s)", file, line, fname);
         ESP_LOGE("malloc", "Failed Allocating memory of size: %d bytes", size);
     }
+#endif
     return ret;
-}
+} /* wc_debug_pvPortMalloc */
+
+#if defined(DEBUG_WOLFSSL_MALLOC) || defined(DEBUG_WOLFSSL)
+void wc_debug_pvPortFree(void *ptr,
+                        const char* file, int line, const char* fname)
+#else
+void wc_pvPortFree(void *ptr)
+#endif
+{
+    wolfSSL_Malloc_cb  mc;
+    wolfSSL_Free_cb    fc;
+    wolfSSL_Realloc_cb rc;
+    if (ptr == NULL) {
+#ifdef DEBUG_WOLFSSL_MALLOC
+        /* It's ok to free a null pointer, and that happens quite frequently */
+#endif
+    }
+    else {
+        wolfSSL_GetAllocators(&mc, &fc, &rc);
+
+        if (fc == NULL) {
+            vPortFree(ptr);
+        }
+        else {
+#if defined(USE_WOLFSSL_MEMORY) && !defined(NO_WOLFSSL_MEMORY)
+            fc(ptr);
+#else
+            vPortFree(ptr);
+#endif
+        }
+    }
+} /* wc_debug_pvPortFree */
+
+#ifndef WOLFSSL_NO_REALLOC
+/* see XREALLOC(p, n, h, t) */
+#if defined(DEBUG_WOLFSSL_MALLOC) || defined(DEBUG_WOLFSSL)
+void* wc_debug_pvPortRealloc(void* ptr, size_t size,
+                             const char* file, int line, const char* fname)
+#else
+void* wc_pvPortRealloc(void* ptr, size_t size)
+#endif
+{
+    void* ret = NULL;
+    wolfSSL_Malloc_cb  mc;
+    wolfSSL_Free_cb    fc;
+    wolfSSL_Realloc_cb rc;
+    wolfSSL_GetAllocators(&mc, &fc, &rc);
+
+    if (mc == NULL) {
+        ret = realloc(ptr, size);
+    }
+    else {
+#if defined(USE_WOLFSSL_MEMORY) && !defined(NO_WOLFSSL_MEMORY)
+        if (rc != NULL) {
+            ret = rc(ptr, size); /* (void *ptr, size_t size) */
+        }
+        else {
+            ret = realloc(ptr, size);
+        }
+#else
+        ret = realloc(ptr, size);
+#endif
+    }
+
+#if defined(DEBUG_WOLFSSL_MALLOC) || defined(DEBUG_WOLFSSL)
+    if (ret == NULL) {
+        ESP_LOGE("realloc", "%s:%d (%s)", file, line, fname);
+        ESP_LOGE("realloc", "Failed Re-allocating memory of size: %d bytes",
+                                                                  size);
+    }
+#endif
+    return ret;
+} /* wc_debug_pvPortRealloc */
+#endif /* WOLFSSL_NO_REALLOC */
 
 #endif
diff --git a/wolfssl/wolfcrypt/port/Espressif/esp-sdk-lib.h b/wolfssl/wolfcrypt/port/Espressif/esp-sdk-lib.h
index 829e9b168..977a95902 100644
--- a/wolfssl/wolfcrypt/port/Espressif/esp-sdk-lib.h
+++ b/wolfssl/wolfcrypt/port/Espressif/esp-sdk-lib.h
@@ -212,8 +212,23 @@ WOLFSSL_LOCAL esp_err_t esp_sdk_wifi_show_ip(void);
 * Debug helpers
 ******************************************************************************/
 WOLFSSL_LOCAL esp_err_t sdk_init_meminfo(void);
+
+#if defined(DEBUG_WOLFSSL_MALLOC) || defined(DEBUG_WOLFSSL)
 WOLFSSL_LOCAL void* wc_debug_pvPortMalloc(size_t size,
                                 const char* file, int line, const char* fname);
+WOLFSSL_LOCAL void wc_debug_pvPortFree(void *ptr,
+                                const char* file, int line, const char* fname);
+#ifndef WOLFSSL_NO_REALLOC
+WOLFSSL_LOCAL void* wc_debug_pvPortRealloc(void* ptr, size_t size,
+                                const char* file, int line, const char* fname);
+#endif
+#else
+WOLFSSL_LOCAL void* wc_pvPortMalloc(size_t size);
+WOLFSSL_LOCAL void wc_pvPortFree(void *ptr);
+#ifndef WOLFSSL_NO_REALLOC
+WOLFSSL_LOCAL void* wc_pvPortRealloc(void* ptr, size_t size);
+#endif
+#endif /*DEBUG_WOLFSSL_MALLOC || DEBUG_WOLFSSL */
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/wolfssl/wolfcrypt/settings.h b/wolfssl/wolfcrypt/settings.h
index fc08d66e2..c1d386b12 100644
--- a/wolfssl/wolfcrypt/settings.h
+++ b/wolfssl/wolfcrypt/settings.h
@@ -1497,27 +1497,53 @@ extern void uITRON4_free(void *p) ;
     #if !defined(XMALLOC_USER) && !defined(NO_WOLFSSL_MEMORY) && \
         !defined(WOLFSSL_STATIC_MEMORY) && !defined(WOLFSSL_TRACK_MEMORY)
 
-        /* XMALLOC */
-        #if defined(WOLFSSL_ESPIDF) && \
-           (defined(DEBUG_WOLFSSL) || defined(DEBUG_WOLFSSL_MALLOC))
+        #if defined(WOLFSSL_ESPIDF)
             #include <wolfssl/wolfcrypt/port/Espressif/esp-sdk-lib.h>
-            #define XMALLOC(s, h, type)  \
-                           ((void)(h), (void)(type), wc_debug_pvPortMalloc( \
-                           (s), (__FILE__), (__LINE__), (__FUNCTION__) ))
+        #endif
+
+        /* XMALLOC */
+        #if defined(WOLFSSL_ESPIDF)
+            #if (defined(DEBUG_WOLFSSL) || defined(DEBUG_WOLFSSL_MALLOC))
+                #define XMALLOC(s, h, type)  \
+                              ((void)(h), (void)(type), wc_debug_pvPortMalloc( \
+                               (s), (__FILE__), (__LINE__), (__FUNCTION__) ))
+            #else
+                #define XMALLOC(s, h, type)  \
+                        ((void)(h), (void)(type), wc_pvPortMalloc((s))) /* native heap */
+            #endif
         #else
             #define XMALLOC(s, h, type)  \
                            ((void)(h), (void)(type), pvPortMalloc((s))) /* native heap */
         #endif
 
         /* XFREE */
-        #define XFREE(p, h, type)    ((void)(h), (void)(type), vPortFree((p))) /* native heap */
+        #if defined(WOLFSSL_ESPIDF)
+            #if (defined(DEBUG_WOLFSSL) || defined(DEBUG_WOLFSSL_MALLOC))
+                #define XFREE(p, h, type)   \
+                        ((void)(h), (void)(type), wc_debug_pvPortFree( \
+                                 (p), (__FILE__), (__LINE__), (__FUNCTION__) ))
+            #else
+                #define XFREE(p, h, type)   \
+                        ((void)(h), (void)(type), wc_pvPortFree((p)))
+            #endif
+        #else
+            #define XFREE(p, h, type)   \
+                     ((void)(h), (void)(type), vPortFree((p))) /* native heap */
+        #endif
 
         /* XREALLOC */
         #if defined(WOLFSSL_ESPIDF)
-            /* In the Espressif EDP-IDF, realloc(p, n) is equivalent to
-             *     heap_caps_realloc(p, s, MALLOC_CAP_8BIT)
-             * There's no pvPortRealloc available:  */
-            #define XREALLOC(p, n, h, t) ((void)(h), (void)(t), realloc((p), (n))) /* native heap */
+            #if (defined(DEBUG_WOLFSSL) || defined(DEBUG_WOLFSSL_MALLOC))
+                #define XREALLOC(p, n, h, t) \
+                        ((void)(h), (void)(t), wc_debug_pvPortRealloc( \
+                        (p), (n),(__FILE__), (__LINE__), (__FUNCTION__) ))
+            #else
+                /* In the Espressif EDP-IDF, realloc(p, n) is equivalent to
+                 *     heap_caps_realloc(p, s, MALLOC_CAP_8BIT)
+                 * There's no pvPortRealloc available, use native heap:  */
+                #define XREALLOC(p, n, h, t) \
+                       ((void)(h), (void)(t), wc_pvPortRealloc((p), (n)))
+            #endif
         #elif defined(USE_INTEGER_HEAP_MATH) || defined(OPENSSL_EXTRA) || \
               defined(OPENSSL_ALL)
             /* FreeRTOS pvPortRealloc() implementation can be found here: