Secure DFU on RT600 Board: RT685 EVK Zephyr toolchain: zephyr-sdk-1.0.1, zsdk nxp-v4.4.1.1 Hi Team! I am working on a Zephyr-based RT600 application, which should include three images in total ( MCUBoot, ARM core image, and DSP core image). Since the RT600 is a flash-less MCU, those images have to live in the external flash, and I am looking for a proper way to protect them against read-back and other potential risks that could leak the image. On top of that, I would like to have the DFU feature to update both the ARM core and the DSP core images via SMP protocol (RT600 running as SMP server, or through MCUBoot serial recovery, or both) in an encrypted manner. I failed to find an example shipped with nxp-zsdk, could you please help me find a practical path to follow? Best regards, Yue Re: Secure DFU on RT600 Hi @YueZ ,
For the RT685 EVK, I recommend treating this as two related design tasks : securing what is stored in external flash, and securely updating the Arm and DSP firmware. An encrypted update alone does not establish that the active image is protected against external-flash read-back.
A practical starting point is to package the DSP firmware with the Arm application and update them as one signed image . That lets you bring up a single MCUboot primary/secondary-slot update path before taking on independent DSP image management. Zephyr’s SMP image-management flow uploads an update to a secondary slot for MCUboot to process at boot.(zephyr/doc/services/device_mgmt/smp_groups/smp_group_1.rst at main · zephyrproject-rtos/zephyr · GitHub) On RT600, the boot images reside outside internal flash, either for loading into SRAM or for execution from external memory, so the flash layout and boot chain need to be designed together. - https://www.nxp.com/docs/en/application-note/AN12985.pdf
I would proceed in this order:
Establish a trusted boot chain : authenticate the bootloader at startup, then have it verify signed application updates. Include production key provisioning and debug-access policy in the design.
Demonstrate a signed Arm-plus-DSP update through an application-side SMP server, with a defined primary and secondary flash slot. Confirm that the newly built DSP firmware is actually included in the image being uploaded.
Address confidentiality of the installed image separately . NXP’s RT600 secure-provisioning workflow describes writing an encrypted application and OTFAD key blobs,(mcuxpresso.nxp.com/secure/latest/_sources/06_processor_specific_workflow.md) and its RT600 FOTA note describes a signed-and-encrypted OTA approach. Those are useful RT600 references, but their procedures are not a ready-made Zephyr SMP integration. - https://www.nxp.com/docs/en/application-note/AN13478.pdf
If independent Arm and DSP updates are required, design separate image storage and verification, plus a way to prevent incompatible Arm/DSP versions from being activated together. I would treat that as a second integration milestone, not as a capability already demonstrated by the combined-image example.
Application-side SMP and bootloader-side serial recovery can both be considered, but they are distinct update paths; you do not need to implement both to validate the first DFU milestone.
Could you confirm whether the DSP must be updated independently, or whether updating Arm and DSP together is acceptable? That decision determines whether the simpler combined-image path meets your requirements or whether a multi-image boot and rollback design is necessary.
Have a great day, Kan
------------------------------------------------------------------------------- Note: - If this post answers your question, please click the "Mark Correct" button. Thank you! - We are following threads for 7 weeks after the last post, later replies are ignored Please open a new thread and refer to the closed one, if you have a related question at a later point in time. ------------------------------------------------------------------------------- Re: Secure DFU on RT600 Hi Kan, Thank you very much for the information, it is really clear and helpful! To answer your question, I am fine with packing the two images into one; they don't need to be separate. Additionally, I am eager to know your suggestions on a few more questions, and please correct me if I am wrong since I am new to the NXP secure-provisioning workflow: The two milestones are, if I understood it correctly: 1) verify FOTA image signing and boot chain; 2) verify OTFAD on the off-chip flash. It looks like the west build process only signs the image without encryption; the output hex(bin) image file remains in plaintext, which is supposed to be encrypted in the second step for OTFAD. On an OTA update, a signed image is received and then written into flash as OTFAD-encrypted. Does that mean the image in transit is exposed to attack? XIP or loading in RAM, which would you recommend for less workload in Zephyr if combined with signing and encryption? Is there an example available in Zephyr demonstrating the OTFAD feature on RT600 (and whether OTFAD is supported by MCUBoot serial recovery)? I found modules/hal/nxp/mcux/mcux-sdk-ng/drivers/otfad/fsl_otfad.h, but nothing has referred to it yet. A starting point would be very much appreciated! Best regards, Yue Re: Secure DFU on RT600 Hi @YueZ ,
Thank you for confirming that the Arm and DSP firmware can be packaged together. That is the path I would start with: one signed application update containing both firmwares , rather than two independently managed application images.
Your proposed milestones are sensible, but I would separate them slightly differently:
Prove the boot and update chain: boot the combined image through MCUboot, upload a signed replacement through application-side SMP, and verify the upgrade and recovery behavior.
Prove encrypted boot on the RT685 EVK: use Secure Provisioning Tool (SPT) to build and boot an OTFAD-encrypted image from external flash, initially using the documented shadow-register development workflow. - Processor-specific workflows — Secure Provisioning Tool 26.09
Integrate the two: determine how a field update will be staged and installed in the encrypted flash layout without breaking image verification or recovery. This last step is not provided automatically by enabling OTFAD. - Generic workflows — Secure Provisioning Tool 26.09
On the plaintext build output and transmission: your understanding is substantially correct. The documented Zephyr/MCUboot workflow produces a signed application file, zephyr.signed.bin ; signing does not conceal its contents. If that file is distributed and uploaded as-is, someone able to obtain the file or observe an unprotected transfer can read the firmware. You can protect the transfer with an appropriately authenticated, encrypted transport, or distribute an encrypted update artifact. These are separate from protecting the installed image in external flash. - Generic workflows — Secure Provisioning Tool 26.09 Encrypted XIP and MCUboot — MCUXpresso SDK Documentation
I would make one correction to the proposed OTA diagram: do not assume that receiving a signed plaintext image and writing it with Zephyr’s flash driver automatically produces OTFAD-encrypted flash contents. SPT’s RT5xx/6xx workflow explicitly writes an encrypted application and OTFAD key blobs . A field updater must reproduce a compatible result—or use another validated installation scheme—while accounting for the protected address ranges and keys. The RT600 OTFAD reference describes decryption of encrypted flash during reads; the SPT provisioning procedure should not be taken as an implementation of Zephyr’s runtime update writer. -https://www.nxp.com/docs/en/training-reference-material/RT600_Security_Architecture_sb.pdf
XIP versus load-to-RAM: since your goal is specifically to protect an application stored in external flash with OTFAD, I would use encrypted XIP as the first security proof of concept . SPT documents that boot workflow for RT5xx/6xx. This is a recommendation for the boot experiment , not a claim that encrypted XIP makes the Zephyr DFU integration easy. Load-to-RAM is also a documented RT5xx/6xx image arrangement, but it does not remove the need to protect the stored image and design a secure update path. I cannot substantiate that either option is a turnkey, lower-workload Zephyr solution for your SDK version.
Regarding examples and serial recovery: I have not found a validated RT685 Zephyr example combining OTFAD, MCUboot and SMP/serial-recovery encrypted updates for nxp-v4.4.1.1 . The fsl_otfad.h header establishes that a driver interface exists; it does not establish that the RT685 MCUboot recovery or flash-installation path integrates it. NXP’s Encrypted XIP and MCUboot documentation describes an encrypted-XIP extension, but its listed OTFAD example boards are RT1152/RT1160/RT1170, not RT685 . I would not assume that its serial-recovery or installation behavior carries over to this board. That is something I still need to check with the team.
For a concrete starting reference, use SPT 26.09, “RT5xx/6xx device workflow → Booting OTFAD encrypted image using shadow registers” to establish the encrypted-boot baseline. In parallel, use AN13478, Implementing FOTA on i.MX RT600 to study NXP’s RT600 signed-and-encrypted update approach. That application note is not a Zephyr SMP example, so the remaining work is to reconcile its encrypted-image installation approach with your Zephyr/MCUboot slot layout and chosen update path.
For this board, I would validate signed combined-image DFU and SPT-generated OTFAD XIP separately, then treat encrypted field installation—including any serial-recovery support—as an integration task requiring its own test.
Have a great day, Kan
------------------------------------------------------------------------------- Note: - If this post answers your question, please click the "Mark Correct" button. Thank you! - We are following threads for 7 weeks after the last post, later replies are ignored Please open a new thread and refer to the closed one, if you have a related question at a later point in time. ------------------------------------------------------------------------------- Re: Secure DFU on RT600 Hi Kan, This is enough information for me to digest at this point, I will mark it as a solution. Please notify me if the team has any updates on the capability of RT685 MCUboot recovery with OTFAD. Thank you very much for the details! You have a great day too! Yue
View full article