diff --git a/boot/bootutil/src/bootutil_public.c b/boot/bootutil/src/bootutil_public.c
index 1021188644..dc118031d9 100644
--- a/boot/bootutil/src/bootutil_public.c
+++ b/boot/bootutil/src/bootutil_public.c
@@ -51,6 +51,11 @@
 #include "bootutil_priv.h"
 #include "bootutil_misc.h"
 
+// TEMP FOR DEBUG - REMOVE
+// #include "bootloader_flash_priv.h"
+
+bool aligned_flash_read_(uintptr_t addr, void *dest, size_t size, bool read_encrypted);
+
 #ifdef CONFIG_MCUBOOT
 BOOT_LOG_MODULE_DECLARE(mcuboot);
 #else
@@ -223,6 +228,13 @@ boot_read_flag(const struct flash_area *fap, uint8_t *flag, uint32_t off)
     if (rc < 0) {
         return BOOT_EFLASH;
     }
+    // TEMP FOR DEBUG - REMOVE
+    uint8_t read_buf;
+    BOOT_LOG_INF("boot_read_flag whats read  rc=0x%x  addr=0x%lx 0x%x", rc, fap->fa_off+off, *flag);
+    rc = aligned_flash_read_(fap->fa_off + off, &read_buf, sizeof(read_buf), false);
+    BOOT_LOG_INF("boot_read_flag whats read - RAW rc=0x%x  0x%x", rc, read_buf);
+    // TEMP FOR DEBUG - REMOVE
+
     if (bootutil_buffer_is_erased(fap, flag, sizeof *flag)) {
         *flag = BOOT_FLAG_UNSET;
     } else {
@@ -235,6 +247,8 @@ boot_read_flag(const struct flash_area *fap, uint8_t *flag, uint32_t off)
 static inline int
 boot_read_copy_done(const struct flash_area *fap, uint8_t *copy_done)
 {
+    BOOT_LOG_INF("boot_read_copy_done");
+
     return boot_read_flag(fap, copy_done, boot_copy_done_off(fap));
 }
 
@@ -248,11 +262,29 @@ boot_read_swap_state(const struct flash_area *fap,
     uint8_t swap_info;
     int rc;
 
+
     off = boot_magic_off(fap);
+    BOOT_LOG_INF("boot_read_swap_state MAGIC addr 0x%lx", fap->fa_off+off);
     rc = flash_area_read(fap, off, magic, BOOT_MAGIC_SZ);
     if (rc < 0) {
         return BOOT_EFLASH;
     }
+
+    // TEMP FOR DEBUG - REMOVE
+    uint8_t read_buf[BOOT_MAGIC_SZ];
+    BOOT_LOG_INF("boot_read_swap_state whats read  rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAGIC_SZ; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            magic[i], magic[i+1], magic[i+2], magic[i+3]);
+    }
+    rc = aligned_flash_read_(fap->fa_off + off, read_buf, BOOT_MAGIC_SZ, false);
+    BOOT_LOG_INF("boot_read_swap_state whats read - RAW rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAGIC_SZ; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    // TEMP FOR DEBUG - REMOVE
+
     if (bootutil_buffer_is_erased(fap, magic, BOOT_MAGIC_SZ)) {
         state->magic = BOOT_MAGIC_UNSET;
     } else {
@@ -260,11 +292,19 @@ boot_read_swap_state(const struct flash_area *fap,
     }
 
     off = boot_swap_info_off(fap);
+    BOOT_LOG_INF("boot_read_swap_state SWAP_INFO addr 0x%lx", fap->fa_off+off);
     rc = flash_area_read(fap, off, &swap_info, sizeof swap_info);
     if (rc < 0) {
         return BOOT_EFLASH;
     }
 
+    // TEMP FOR DEBUG - REMOVE
+    uint8_t read_buf_swap;
+    BOOT_LOG_INF("boot_read_swap_state whats read  rc=0x%x  0x%x", rc, swap_info);
+    rc = aligned_flash_read_(fap->fa_off + off, &read_buf_swap, sizeof(swap_info), false);
+    BOOT_LOG_INF("boot_read_swap_state whats read - RAW rc=0x%x  0x%x", rc, read_buf_swap);
+    // TEMP FOR DEBUG - REMOVE
+
     /* Extract the swap type and image number */
     state->swap_type = BOOT_GET_SWAP_TYPE(swap_info);
     state->image_num = BOOT_GET_IMAGE_NUM(swap_info);
@@ -327,12 +367,52 @@ boot_write_magic(const struct flash_area *fap)
     BOOT_LOG_DBG("writing magic; fa_id=%d off=0x%lx (0x%lx)",
                  flash_area_get_id(fap), (unsigned long)off,
                  (unsigned long)(flash_area_get_off(fap) + off));
+
+#ifdef MCUBOOT_FLASH_HAS_HW_ENCRYPTION
+    BOOT_LOG_INF("boot_write_magic writing MAGIC; fa_id=%d off=0x%lx (0x%lx) size=0%0x",
+        flash_area_get_id(fap), (unsigned long)pad_off,
+        (unsigned long)(flash_area_get_off(fap) + pad_off), BOOT_MAGIC_ALIGN_SIZE);
+    rc = flash_area_erase(fap, pad_off, BOOT_MAGIC_ALIGN_SIZE);
+
+    // TEMP FOR DEBUG - REMOVE
+    uint8_t read_buf[BOOT_MAGIC_ALIGN_SIZE];
+    rc = flash_area_read(fap, pad_off, read_buf, BOOT_MAGIC_ALIGN_SIZE);
+    BOOT_LOG_INF("boot_write_magic whats read BEFORE writing rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAGIC_ALIGN_SIZE; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    rc = aligned_flash_read_(fap->fa_off + pad_off, read_buf, BOOT_MAGIC_ALIGN_SIZE, false);
+    BOOT_LOG_INF("boot_write_magic whats read BEFORE writing - RAW rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAGIC_ALIGN_SIZE; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    // TEMP FOR DEBUG - REMOVE
+
+#endif
+
     rc = flash_area_write(fap, pad_off, &magic[0], BOOT_MAGIC_ALIGN_SIZE);
 
     if (rc != 0) {
         return BOOT_EFLASH;
     }
 
+    // TEMP FOR DEBUG - REMOVE
+    rc = flash_area_read(fap, pad_off, read_buf, BOOT_MAGIC_ALIGN_SIZE);
+    BOOT_LOG_INF("boot_write_magic whats read AFTER writing rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAGIC_ALIGN_SIZE; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    rc = aligned_flash_read_(fap->fa_off + pad_off, read_buf, BOOT_MAGIC_ALIGN_SIZE, false);
+    BOOT_LOG_INF("boot_write_magic whats read AFTER writing - RAW rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAGIC_ALIGN_SIZE; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    // TEMP FOR DEBUG - REMOVE
+
     return 0;
 }
 
@@ -360,11 +440,71 @@ boot_write_trailer(const struct flash_area *fap, uint32_t off,
     memcpy(buf, inbuf, inlen);
     memset(&buf[inlen], erased_val, align - inlen);
 
+#ifdef MCUBOOT_FLASH_HAS_HW_ENCRYPTION
+
+    BOOT_LOG_INF("boot_write_trailer writing TRAILER; fa_id=%d off=0x%lx (0x%lx) size=0x%x",
+        flash_area_get_id(fap), (unsigned long)off,
+        (unsigned long)(flash_area_get_off(fap) + off), align);
+    rc = flash_area_erase(fap, off, align);
+
+    // TEMP FOR DEBUG - REMOVE
+    uint8_t read_buf[BOOT_MAX_ALIGN];
+
+    if ((unsigned long)(flash_area_get_off(fap) + off) == 0x16FFA0) {
+        BOOT_LOG_INF("boot_write_trailer 0x16FFA0 CASE");
+
+        rc = flash_area_read(fap, off + BOOT_MAX_ALIGN, read_buf, BOOT_MAX_ALIGN);
+        BOOT_LOG_INF("boot_write_trailer whats read in addr 0x%lx AFTER ERASE rc=0x%x",
+                    (unsigned long)(flash_area_get_off(fap) + off + BOOT_MAX_ALIGN), rc);
+        for (uint8_t i=0; i<BOOT_MAX_ALIGN; i=i+4) {
+            BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+                read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+        }
+        rc = aligned_flash_read_(fap->fa_off + off + BOOT_MAX_ALIGN, read_buf, BOOT_MAX_ALIGN, false);
+        BOOT_LOG_INF("boot_write_trailer whats read in addr 0x%lx AFTER ERASE - RAW rc=0x%x",
+                    (unsigned long)(flash_area_get_off(fap) + off + BOOT_MAX_ALIGN), rc);
+        for (uint8_t i=0; i<BOOT_MAX_ALIGN; i=i+4) {
+            BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+                read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+        }
+    }
+
+    rc = flash_area_read(fap, off, read_buf, BOOT_MAX_ALIGN);
+    BOOT_LOG_INF("boot_write_trailer whats read BEFORE writing rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAX_ALIGN; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    rc = aligned_flash_read_(fap->fa_off + off, read_buf, BOOT_MAX_ALIGN, false);
+    BOOT_LOG_INF("boot_write_trailer whats read BEFORE writing - RAW rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAX_ALIGN; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    // TEMP FOR DEBUG - REMOVE
+
+#endif
+
     rc = flash_area_write(fap, off, buf, align);
     if (rc != 0) {
         return BOOT_EFLASH;
     }
 
+    // TEMP FOR DEBUG - REMOVE
+    rc = flash_area_read(fap, off, read_buf, BOOT_MAX_ALIGN);
+    BOOT_LOG_INF("boot_write_trailer whats read AFTER writing rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAX_ALIGN; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    rc = aligned_flash_read_(fap->fa_off + off, read_buf, BOOT_MAX_ALIGN, false);
+    BOOT_LOG_INF("boot_write_trailer whats read AFTER writing - RAW rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAX_ALIGN; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    // TEMP FOR DEBUG - REMOVE
+
     return 0;
 }
 
@@ -382,7 +522,7 @@ boot_write_image_ok(const struct flash_area *fap)
     uint32_t off;
 
     off = boot_image_ok_off(fap);
-    BOOT_LOG_DBG("writing image_ok; fa_id=%d off=0x%lx (0x%lx)",
+    BOOT_LOG_INF("boot_write_image_ok writing IMAGE_OK; fa_id=%d off=0x%lx (0x%lx)",
                  flash_area_get_id(fap), (unsigned long)off,
                  (unsigned long)(flash_area_get_off(fap) + off));
     return boot_write_trailer_flag(fap, off, BOOT_FLAG_SET);
@@ -391,6 +531,7 @@ boot_write_image_ok(const struct flash_area *fap)
 int
 boot_read_image_ok(const struct flash_area *fap, uint8_t *image_ok)
 {
+    BOOT_LOG_INF("boot_read_image_ok");
     return boot_read_flag(fap, image_ok, boot_image_ok_off(fap));
 }
 
@@ -408,7 +549,7 @@ boot_write_swap_info(const struct flash_area *fap, uint8_t swap_type,
 
     BOOT_SET_SWAP_INFO(swap_info, image_num, swap_type);
     off = boot_swap_info_off(fap);
-    BOOT_LOG_DBG("writing swap_info; fa_id=%d off=0x%lx (0x%lx), swap_type=0x%x"
+    BOOT_LOG_INF("boot_write_swap_info writing SWAP_INFO; fa_id=%d off=0x%lx (0x%lx), swap_type=0x%x"
                  " image_num=0x%x",
                  flash_area_get_id(fap), (unsigned long)off,
                  (unsigned long)(flash_area_get_off(fap) + off),
@@ -492,7 +633,7 @@ boot_write_copy_done(const struct flash_area *fap)
     uint32_t off;
 
     off = boot_copy_done_off(fap);
-    BOOT_LOG_DBG("writing copy_done; fa_id=%d off=0x%lx (0x%lx)",
+    BOOT_LOG_INF("boot_write_copy_done writing COPY_DONE; fa_id=%d off=0x%lx (0x%lx)",
                  flash_area_get_id(fap), (unsigned long)off,
                  (unsigned long)(flash_area_get_off(fap) + off));
     return boot_write_trailer_flag(fap, off, BOOT_FLAG_SET);
@@ -534,11 +675,17 @@ boot_set_next(const struct flash_area *fa, bool active, bool confirm)
         return rc;
     }
 
+    BOOT_LOG_INF("boot_set_next; fa_id=%d slot_state.magic=0x%lx slot_state.image_ok=0x%lx slot_state.swap_type=0x%lx",
+        flash_area_get_id(fa), slot_state.magic, slot_state.image_ok, slot_state.swap_type);
+
     switch (slot_state.magic) {
     case BOOT_MAGIC_GOOD:
         /* If non-active then swap already scheduled, else confirm needed.*/
-
+        BOOT_LOG_INF("boot_set_next; fa_id=%d slot_state.magic=0x%lx (BOOT_MAGIC_GOOD)",
+                    flash_area_get_id(fa), slot_state.magic);
         if (active && slot_state.image_ok == BOOT_FLAG_UNSET) {
+            BOOT_LOG_INF("boot_set_next; fa_id=%d slot_state.magic=0x%lx slot_state.image_ok=0x%lx (BOOT_FLAG_UNSET)",
+                    flash_area_get_id(fa), slot_state.magic, slot_state.image_ok);
             /* Intentionally do not check copy_done flag to be able to
              * confirm a padded image which has been programmed using
              * a programming interface.
@@ -549,6 +696,8 @@ boot_set_next(const struct flash_area *fa, bool active, bool confirm)
         break;
 
     case BOOT_MAGIC_UNSET:
+        BOOT_LOG_INF("boot_set_next; fa_id=%d slot_state.magic=0x%lx (BOOT_MAGIC_UNSET)",
+                    flash_area_get_id(fa), slot_state.magic);
         if (!active) {
             rc = boot_write_magic(fa);
 
@@ -570,6 +719,8 @@ boot_set_next(const struct flash_area *fa, bool active, bool confirm)
         break;
 
     case BOOT_MAGIC_BAD:
+        BOOT_LOG_INF("boot_set_next; fa_id=%d slot_state.magic=0x%lx (BOOT_MAGIC_BAD)",
+                flash_area_get_id(fa), slot_state.magic);
         if (active) {
             rc = BOOT_EBADVECT;
         } else {
@@ -582,6 +733,8 @@ boot_set_next(const struct flash_area *fa, bool active, bool confirm)
         break;
 
     default:
+        BOOT_LOG_INF("boot_set_next; fa_id=%d slot_state.magic=0x%lx (SHOULD NEVER HAPPEN)",
+                flash_area_get_id(fa), slot_state.magic);
         /* Something is not OK, this should never happen */
         assert(0);
         rc = BOOT_EBADIMAGE;
@@ -761,6 +914,10 @@ boot_image_load_header(const struct flash_area *fa_p,
                        struct image_header *hdr)
 {
     uint32_t size;
+
+    BOOT_LOG_INF("boot_image_load_header; fa_id=%d addr=0x%lx",
+                 flash_area_get_id(fa_p), (unsigned long)(flash_area_get_off(fa_p)));
+
     int rc = flash_area_read(fa_p, 0, hdr, sizeof *hdr);
 
     if (rc != 0) {
@@ -786,5 +943,8 @@ boot_image_load_header(const struct flash_area *fa_p,
         return BOOT_EBADIMAGE;
     }
 
+    BOOT_LOG_INF("boot_image_load_header; ih_magic=0%lx ih_flags=0x%lx ih_hdr_size=0x%lx ih_img_size=0x%lx",
+                hdr->ih_magic, hdr->ih_flags, hdr->ih_hdr_size, hdr->ih_img_size);
+
     return 0;
 }
diff --git a/boot/bootutil/src/loader.c b/boot/bootutil/src/loader.c
index 62f980b69c..295fed1d29 100644
--- a/boot/bootutil/src/loader.c
+++ b/boot/bootutil/src/loader.c
@@ -50,6 +50,9 @@
 #include "bootutil/boot_hooks.h"
 #include "bootutil/mcuboot_status.h"
 
+// TEMP FOR DEBUG - REMOVE
+#include "bootloader_flash_priv.h"
+
 #ifdef MCUBOOT_ENC_IMAGES
 #include "bootutil/enc_key.h"
 #endif
@@ -751,11 +754,49 @@ boot_write_status(const struct boot_loader_state *state, struct boot_status *bs)
                  flash_area_get_id(fap), (unsigned long)off,
                  (unsigned long)flash_area_get_off(fap) + off);
 
+#ifdef MCUBOOT_FLASH_HAS_HW_ENCRYPTION
+    BOOT_LOG_INF("loader.c writing SWAP STATUS; fa_id=%d off=0x%lx (0x%lx)",
+        flash_area_get_id(fap), (unsigned long)off,
+        (unsigned long)(flash_area_get_off(fap) + off));
+    rc = flash_area_erase(fap, off, align);
+
+    // TEMP FOR DEBUG - REMOVE
+    uint8_t read_buf[BOOT_MAX_ALIGN];
+    rc = flash_area_read(fap, off, read_buf, BOOT_MAX_ALIGN);
+    BOOT_LOG_INF("whats read BEFORE writing rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAX_ALIGN; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    rc = bootloader_flash_read(fap->fa_off + off, read_buf, BOOT_MAX_ALIGN, false);
+    BOOT_LOG_INF("whats read BEFORE writing - RAW rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAX_ALIGN; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    // TEMP FOR DEBUG - REMOVE
+
+#endif
     rc = flash_area_write(fap, off, buf, align);
     if (rc != 0) {
         rc = BOOT_EFLASH;
     }
 
+    // TEMP FOR DEBUG - REMOVE
+    rc = flash_area_read(fap, off, read_buf, BOOT_MAX_ALIGN);
+    BOOT_LOG_INF("whats read AFTER writing rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAX_ALIGN; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    rc = bootloader_flash_read(fap->fa_off + off, read_buf, BOOT_MAX_ALIGN, false);
+    BOOT_LOG_INF("whats read AFTER writing - RAW rc=0x%x", rc);
+    for (uint8_t i=0; i<BOOT_MAX_ALIGN; i=i+4) {
+        BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+            read_buf[i], read_buf[i+1], read_buf[i+2], read_buf[i+3]);
+    }
+    // TEMP FOR DEBUG - REMOVE
+
     return rc;
 }
 #endif /* !MCUBOOT_RAM_LOAD */
diff --git a/boot/bootutil/src/swap_misc.c b/boot/bootutil/src/swap_misc.c
index ac9412b0fd..e05b3a2c43 100644
--- a/boot/bootutil/src/swap_misc.c
+++ b/boot/bootutil/src/swap_misc.c
@@ -64,6 +64,40 @@ swap_erase_trailer_sectors(const struct boot_loader_state *state,
             rc = boot_erase_region(fap, off, sz, false);
             assert(rc == 0);
 
+#ifdef MCUBOOT_FLASH_HAS_HW_ENCRYPTION
+        /* MCUboot's state machine relies on erased valued data
+         * (e.g. 0xFF) readed from this erased region that could
+         * be not written  before, however if the flash device has
+         * hardware flash encryption and its flash read operation
+         * always decrypts what is being read from flash, thus a
+         * region that was erased would not be read as what
+         * MCUboot expected (after erasing, the region
+         * physically contains 0xFF, but once reading it, flash
+         * controller decrypts 0xFF to something else).
+         * So this configuration force the erased value into the
+         * region after the erasing.
+         */
+#ifndef MIN
+#  define MIN(a, b)                 (((a) < (b)) ? (a) : (b))
+#endif
+
+        uint8_t write_data[FLASH_AUX_WRITE_BUFFER_SIZE];
+        memset(write_data, flash_area_erased_val(fap), sizeof(write_data));
+        uint32_t bytes_remaining = sz;
+        uint32_t offset = off;
+
+        uint32_t bytes_written = MIN(sizeof(write_data), sz);
+        while (bytes_remaining != 0) {
+            if (flash_area_write(fap, offset, write_data, bytes_written)) {
+                BOOT_LOG_ERR("%s: Force write erased value after erasing a trailer region failed", __func__);
+                rc = -1;
+                break;
+            }
+            offset += bytes_written;
+            bytes_remaining -= bytes_written;
+        }
+#endif // MCUBOOT_FLASH_HAS_HW_ENCRYPTION
+
             sector--;
             total_sz += sz;
         } while (total_sz < trailer_sz);
diff --git a/boot/espressif/CMakeLists.txt b/boot/espressif/CMakeLists.txt
index 05358839c1..da1903eed6 100644
--- a/boot/espressif/CMakeLists.txt
+++ b/boot/espressif/CMakeLists.txt
@@ -13,8 +13,9 @@ endif()
 
 add_definitions(-DMCUBOOT_TARGET=${MCUBOOT_TARGET})
 add_definitions(-D__ESPRESSIF__=1)
+add_definitions(-DCONFIG_MCUBOOT_ESPRESSIF=1)
 
-set(EXPECTED_IDF_HAL_VERSION "5.1.4")
+set(EXPECTED_IDF_HAL_VERSION "5.1.5")
 
 if ("${MCUBOOT_TARGET}" STREQUAL "esp32" OR
     "${MCUBOOT_TARGET}" STREQUAL "esp32s2" OR
diff --git a/boot/espressif/hal/include/esp32s3/sdkconfig.h b/boot/espressif/hal/include/esp32s3/sdkconfig.h
index 9d57623587..6ba4ac0ee1 100644
--- a/boot/espressif/hal/include/esp32s3/sdkconfig.h
+++ b/boot/espressif/hal/include/esp32s3/sdkconfig.h
@@ -22,7 +22,7 @@
 #define CONFIG_ESP_CONSOLE_UART_BAUDRATE 115200
 #define CONFIG_BOOTLOADER_OFFSET_IN_FLASH 0x0000
 #define CONFIG_PARTITION_TABLE_OFFSET 0x10000
-#define CONFIG_EFUSE_VIRTUAL_OFFSET 0x250000
+#define CONFIG_EFUSE_VIRTUAL_OFFSET 0x3FF000
 #define CONFIG_EFUSE_VIRTUAL_SIZE 0x2000
 #define CONFIG_EFUSE_MAX_BLK_LEN 256
 #define CONFIG_BOOTLOADER_FLASH_XMC_SUPPORT 1
diff --git a/boot/espressif/hal/include/mcuboot_config/mcuboot_config.h b/boot/espressif/hal/include/mcuboot_config/mcuboot_config.h
index 2435172d81..8d4ef5e5db 100644
--- a/boot/espressif/hal/include/mcuboot_config/mcuboot_config.h
+++ b/boot/espressif/hal/include/mcuboot_config/mcuboot_config.h
@@ -33,6 +33,14 @@
 #define MCUBOOT_BOOT_MAX_ALIGN 32
 #endif
 
+#ifdef CONFIG_SECURE_FLASH_ENC_ENABLED
+#define MCUBOOT_FLASH_HAS_HW_ENCRYPTION 1
+#endif
+
+#ifdef MCUBOOT_FLASH_HAS_HW_ENCRYPTION
+#define FLASH_AUX_WRITE_BUFFER_SIZE 0x100
+#endif
+
 /*
  * Upgrade mode
  *
diff --git a/boot/espressif/hal/include/stubs.h b/boot/espressif/hal/include/stubs.h
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/boot/espressif/hal/include/zephyr_compat.h b/boot/espressif/hal/include/zephyr_compat.h
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/boot/espressif/port/esp32c3/bootloader.conf b/boot/espressif/port/esp32c3/bootloader.conf
index 8ebd1b40ec..d28c87d52c 100644
--- a/boot/espressif/port/esp32c3/bootloader.conf
+++ b/boot/espressif/port/esp32c3/bootloader.conf
@@ -9,12 +9,12 @@
 CONFIG_ESP_FLASH_SIZE=4MB
 CONFIG_ESP_BOOTLOADER_SIZE=0xF000
 CONFIG_ESP_BOOTLOADER_OFFSET=0x0000
-CONFIG_ESP_IMAGE0_PRIMARY_START_ADDRESS=0x10000
-CONFIG_ESP_APPLICATION_SIZE=0x100000
-CONFIG_ESP_IMAGE0_SECONDARY_START_ADDRESS=0x110000
+CONFIG_ESP_IMAGE0_PRIMARY_START_ADDRESS=0x20000
+CONFIG_ESP_APPLICATION_SIZE=0x1C0000
+CONFIG_ESP_IMAGE0_SECONDARY_START_ADDRESS=0x1E0000
 CONFIG_ESP_MCUBOOT_WDT_ENABLE=y
-CONFIG_ESP_SCRATCH_OFFSET=0x210000
-CONFIG_ESP_SCRATCH_SIZE=0x40000
+CONFIG_ESP_SCRATCH_OFFSET=0x3e0000
+CONFIG_ESP_SCRATCH_SIZE=0x1F000
 
 # When enabled, prevents updating image to an older version
 # CONFIG_ESP_DOWNGRADE_PREVENTION=y
@@ -79,13 +79,13 @@ CONFIG_ESP_CONSOLE_UART_NUM=0
 # CONFIG_SECURE_BOOT_SUPPORTS_RSA=1
 
 # Hardware Flash Encryption related options
-# CONFIG_SECURE_FLASH_ENC_ENABLED=1
-# CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=1
-# CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=1
-# CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=1
-# CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=1
-# CONFIG_SECURE_BOOT_ALLOW_JTAG=1
-# CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=1
+CONFIG_SECURE_FLASH_ENC_ENABLED=1
+CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=1
+CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=1
+CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=1
+CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=1
+CONFIG_SECURE_BOOT_ALLOW_JTAG=1
+CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=1
 
 # Options for enabling eFuse emulation in Flash
 # CONFIG_EFUSE_VIRTUAL=1
diff --git a/boot/espressif/port/esp32s3/bootloader.conf b/boot/espressif/port/esp32s3/bootloader.conf
index a45c0cd193..617164017e 100644
--- a/boot/espressif/port/esp32s3/bootloader.conf
+++ b/boot/espressif/port/esp32s3/bootloader.conf
@@ -6,15 +6,15 @@
 # CONFIG_ESP_BOOT_SWAP_USING_MOVE=y
 # CONFIG_ESP_BOOT_UPGRADE_ONLY=y
 
-CONFIG_ESP_FLASH_SIZE=4MB
+CONFIG_ESP_FLASH_SIZE=8MB
 CONFIG_ESP_BOOTLOADER_SIZE=0xF000
 CONFIG_ESP_BOOTLOADER_OFFSET=0x0000
-CONFIG_ESP_IMAGE0_PRIMARY_START_ADDRESS=0x10000
-CONFIG_ESP_APPLICATION_SIZE=0x100000
-CONFIG_ESP_IMAGE0_SECONDARY_START_ADDRESS=0x110000
+CONFIG_ESP_IMAGE0_PRIMARY_START_ADDRESS=0x20000
+CONFIG_ESP_APPLICATION_SIZE=0x150000
+CONFIG_ESP_IMAGE0_SECONDARY_START_ADDRESS=0x170000
 CONFIG_ESP_MCUBOOT_WDT_ENABLE=y
-CONFIG_ESP_SCRATCH_OFFSET=0x210000
-CONFIG_ESP_SCRATCH_SIZE=0x40000
+CONFIG_ESP_SCRATCH_OFFSET=0x3E0000
+CONFIG_ESP_SCRATCH_SIZE=0x1F000
 
 # When enabled, prevents updating image to an older version
 # CONFIG_ESP_DOWNGRADE_PREVENTION=y
@@ -99,13 +99,13 @@ CONFIG_ESP_CONSOLE_UART_NUM=0
 # CONFIG_SECURE_BOOT_SUPPORTS_RSA=1
 
 # Hardware Flash Encryption related options
-# CONFIG_SECURE_FLASH_ENC_ENABLED=1
-# CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=1
-# CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=1
-# CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=1
-# CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=1
-# CONFIG_SECURE_BOOT_ALLOW_JTAG=1
-# CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=1
+CONFIG_SECURE_FLASH_ENC_ENABLED=1
+CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_ENC=1
+CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_DEC=1
+CONFIG_SECURE_FLASH_UART_BOOTLOADER_ALLOW_CACHE=1
+CONFIG_SECURE_FLASH_ENCRYPTION_MODE_DEVELOPMENT=1
+CONFIG_SECURE_BOOT_ALLOW_JTAG=1
+CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC=1
 
 # Options for enabling eFuse emulation in Flash
 # CONFIG_EFUSE_VIRTUAL=1
diff --git a/boot/espressif/port/esp_mcuboot.c b/boot/espressif/port/esp_mcuboot.c
index 9bbd5a9f20..72a35c9ba1 100644
--- a/boot/espressif/port/esp_mcuboot.c
+++ b/boot/espressif/port/esp_mcuboot.c
@@ -148,6 +148,53 @@ void flash_area_close(const struct flash_area *area)
 
 }
 
+bool aligned_flash_read_(uintptr_t addr, void *dest, size_t size, bool read_encrypted)
+{
+    if (IS_ALIGNED(addr, 4) && IS_ALIGNED((uintptr_t)dest, 4) && IS_ALIGNED(size, 4)) {
+        /* A single read operation is enough when when all parameters are aligned */
+
+        return bootloader_flash_read(addr, dest, size, read_encrypted) == ESP_OK;
+    }
+
+    const uint32_t aligned_addr = ALIGN_DOWN(addr, 4);
+    const uint32_t addr_offset = ALIGN_OFFSET(addr, 4);
+    uint32_t bytes_remaining = size;
+    uint8_t read_data[FLASH_BUFFER_SIZE] = {0};
+
+    /* Align the read address to 4-byte boundary and ensure read size is a multiple of 4 bytes */
+
+    uint32_t bytes = MIN(bytes_remaining + addr_offset, sizeof(read_data));
+    if (bootloader_flash_read(aligned_addr, read_data, ALIGN_UP(bytes, 4), read_encrypted) != ESP_OK) {
+        return false;
+    }
+
+    /* Skip non-useful data which may have been read for adjusting the alignment */
+
+    uint32_t bytes_read = bytes - addr_offset;
+    memcpy(dest, &read_data[addr_offset], bytes_read);
+
+    bytes_remaining -= bytes_read;
+
+    /* Read remaining data from Flash in case requested size is greater than buffer size */
+
+    uint32_t offset = bytes;
+
+    while (bytes_remaining != 0) {
+        bytes = MIN(bytes_remaining, sizeof(read_data));
+        if (bootloader_flash_read(aligned_addr + offset, read_data, ALIGN_UP(bytes, 4), read_encrypted) != ESP_OK) {
+            return false;
+        }
+
+        memcpy(&((uint8_t *)dest)[bytes_read], read_data, bytes);
+
+        offset += bytes;
+        bytes_read += bytes;
+        bytes_remaining -= bytes;
+    }
+
+    return true;
+}
+
 static bool aligned_flash_read(uintptr_t addr, void *dest, size_t size)
 {
     if (IS_ALIGNED(addr, 4) && IS_ALIGNED((uintptr_t)dest, 4) && IS_ALIGNED(size, 4)) {
@@ -277,6 +324,111 @@ static bool aligned_flash_write(size_t dest_addr, const void *src, size_t size)
     return true;
 }
 
+static bool aligned_flash_erase(size_t addr, size_t size)
+{
+    if (IS_ALIGNED(addr, FLASH_SECTOR_SIZE) && IS_ALIGNED(size, FLASH_SECTOR_SIZE)) {
+        /* A single write operation is enough when all parameters are aligned */
+
+        return bootloader_flash_erase_range(addr, size) == ESP_OK;
+    }
+
+    const uint32_t aligned_addr = ALIGN_DOWN(addr, FLASH_SECTOR_SIZE);
+    const uint32_t addr_offset = ALIGN_OFFSET(addr, FLASH_SECTOR_SIZE);
+    uint32_t bytes_remaining = size;
+    uint8_t write_data[FLASH_SECTOR_SIZE] = {0};
+
+    /* Perform a read operation considering an offset not aligned to 4-byte boundary */
+
+    uint32_t bytes = MIN(bytes_remaining + addr_offset, sizeof(write_data));
+
+    // TEMP FOR DEBUG - REMOVE
+    if (addr == 0x16ffa0) {
+        BOOT_LOG_INF("%s: addr unaligned 0x16ffa0 whats read on 0x%lx sector BEFORE erasing - RAW", __func__, aligned_addr);
+        bootloader_flash_read(aligned_addr, write_data, FLASH_SECTOR_SIZE, false);
+        for (uint32_t i=0; i<FLASH_SECTOR_SIZE; i=i+4) {
+            BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+                write_data[i], write_data[i+1], write_data[i+2], write_data[i+3]);
+        }
+    }
+    // TEMP FOR DEBUG - REMOVE
+
+    if (bootloader_flash_read(aligned_addr, write_data, ALIGN_UP(bytes, FLASH_SECTOR_SIZE), true) != ESP_OK) {
+        return false;
+    }
+
+    // TEMP FOR DEBUG - REMOVE
+    if (addr == 0x16ffa0) {
+        BOOT_LOG_INF("%s: addr unaligned 0x16ffa0 whats read on 0x%lx sector BEFORE erasing", __func__, aligned_addr);
+        for (uint32_t i=0; i<FLASH_SECTOR_SIZE; i=i+4) {
+            BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+                write_data[i], write_data[i+1], write_data[i+2], write_data[i+3]);
+        }
+    }
+    // TEMP FOR DEBUG - REMOVE
+
+    if (bootloader_flash_erase_range(aligned_addr, ALIGN_UP(bytes, FLASH_SECTOR_SIZE)) != ESP_OK) {
+        BOOT_LOG_ERR("%s: Flash erase failed", __func__);
+        return -1;
+    }
+
+    uint32_t bytes_written = bytes - addr_offset;
+
+    /* Write first part of non-erased data */
+    if(addr_offset > 0) {
+        aligned_flash_write(aligned_addr, write_data, addr_offset);
+    }
+
+    if(bytes < sizeof(write_data)) {
+        aligned_flash_write(aligned_addr + bytes, write_data + bytes, sizeof(write_data) - bytes);
+    }
+
+    bytes_remaining -= bytes_written;
+
+    /* Write remaining data to Flash if any */
+
+    uint32_t offset = bytes;
+
+    while (bytes_remaining != 0) {
+        bytes = MIN(bytes_remaining, sizeof(write_data));
+        if (bootloader_flash_read(aligned_addr + offset, write_data, ALIGN_UP(bytes, FLASH_SECTOR_SIZE), true) != ESP_OK) {
+            return false;
+        }
+
+        if (bootloader_flash_erase_range(aligned_addr + offset, ALIGN_UP(bytes, FLASH_SECTOR_SIZE)) != ESP_OK) {
+            BOOT_LOG_ERR("%s: Flash erase failed", __func__);
+            return -1;
+        }
+
+        if(bytes < sizeof(write_data)) {
+            aligned_flash_write(aligned_addr + offset + bytes, write_data + bytes, sizeof(write_data) - bytes);
+        }
+
+        offset += bytes;
+        bytes_written += bytes;
+        bytes_remaining -= bytes;
+    }
+
+    // TEMP FOR DEBUG - REMOVE
+    if (addr == 0x16ffa0) {
+        bootloader_flash_read(aligned_addr, write_data, FLASH_SECTOR_SIZE, false);
+        BOOT_LOG_INF("%s: addr unaligned 0x16ffa0 whats read on 0x%lx sector AFTER erasing - RAW", __func__, aligned_addr);
+        for (uint32_t i=0; i<FLASH_SECTOR_SIZE; i=i+4) {
+            BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+                write_data[i], write_data[i+1], write_data[i+2], write_data[i+3]);
+        }
+
+        bootloader_flash_read(aligned_addr, write_data, FLASH_SECTOR_SIZE, true);
+        BOOT_LOG_INF("%s: addr unaligned 0x16ffa0 whats read on 0x%lx sector AFTER erasing", __func__, aligned_addr);
+        for (uint32_t i=0; i<FLASH_SECTOR_SIZE; i=i+4) {
+            BOOT_LOG_INF("0x%x 0x%x 0x%x 0x%x",
+                write_data[i], write_data[i+1], write_data[i+2], write_data[i+3]);
+        }
+    }
+    // TEMP FOR DEBUG - REMOVE
+
+    return true;
+}
+
 int flash_area_write(const struct flash_area *fa, uint32_t off, const void *src,
                      uint32_t len)
 {
@@ -293,8 +445,8 @@ int flash_area_write(const struct flash_area *fa, uint32_t off, const void *src,
     const uint32_t start_addr = fa->fa_off + off;
     BOOT_LOG_DBG("%s: Addr: 0x%08x Length: %d", __func__, (int)start_addr, (int)len);
 
-    bool success = aligned_flash_write(start_addr, src, len);
-    if (!success) {
+
+    if (!aligned_flash_write(start_addr, src, len)) {
         BOOT_LOG_ERR("%s: Flash write failed", __func__);
         return -1;
     }
@@ -308,19 +460,24 @@ int flash_area_erase(const struct flash_area *fa, uint32_t off, uint32_t len)
         return -1;
     }
 
+    const uint32_t start_addr = fa->fa_off + off;
+
     if ((len % FLASH_SECTOR_SIZE) != 0 || (off % FLASH_SECTOR_SIZE) != 0) {
-        BOOT_LOG_ERR("%s: Not aligned on sector Offset: 0x%x Length: 0x%x",
-                     __func__, (int)off, (int)len);
-        return -1;
-    }
+        BOOT_LOG_DBG("%s: Not aligned on sector Offset: 0x%x Length: 0x%x",
+                     __func__, (int)start_addr, (int)len);
 
-    const uint32_t start_addr = fa->fa_off + off;
-    BOOT_LOG_DBG("%s: Addr: 0x%08x Length: %d", __func__, (int)start_addr, (int)len);
+        if(!aligned_flash_erase(start_addr, len)) {
+            return -1;
+        }
+    } else {
+        BOOT_LOG_DBG("%s: Aligned Addr: 0x%08x Length: %d", __func__, (int)start_addr, (int)len);
 
-    if (bootloader_flash_erase_range(start_addr, len) != ESP_OK) {
-        BOOT_LOG_ERR("%s: Flash erase failed", __func__);
-        return -1;
+        if (bootloader_flash_erase_range(start_addr, len) != ESP_OK) {
+            BOOT_LOG_ERR("%s: Flash erase failed", __func__);
+            return -1;
+        }
     }
+
 #if VALIDATE_PROGRAM_OP
     for (size_t i = 0; i < len; i++) {
         uint8_t *val = (void *)(start_addr + i);