diff --git a/.github/.wordlist.txt b/.github/.wordlist.txt
index ef5aa8f..04179cb 100644
--- a/.github/.wordlist.txt
+++ b/.github/.wordlist.txt
@@ -1071,7 +1071,6 @@
 ProxyValid
 ProxyView
 PRs
-PSA
 PSCAN
 PSECT
 PSK
diff --git a/.github/workflows/examples-openiotsdk.yaml b/.github/workflows/examples-openiotsdk.yaml
index d706b8d..2c373d4 100644
--- a/.github/workflows/examples-openiotsdk.yaml
+++ b/.github/workflows/examples-openiotsdk.yaml
@@ -31,11 +31,6 @@
 
 jobs:
     openiotsdk:
-        strategy:
-            fail-fast: false
-            matrix:
-                cryptoBackend: ["psa", "mbedtls"]
-
         name: Open IoT SDK examples building
         timeout-minutes: 90
 
@@ -94,7 +89,7 @@
               id: build_shell
               timeout-minutes: 10
               run: |
-                  scripts/examples/openiotsdk_example.sh -b ${{ matrix.cryptoBackend }} shell
+                  scripts/examples/openiotsdk_example.sh shell
                   .environment/pigweed-venv/bin/python3 scripts/tools/memory/gh_sizes.py \
                     openiotsdk release shell \
                     examples/shell/openiotsdk/build/chip-openiotsdk-shell-example.elf \
@@ -104,7 +99,7 @@
               id: build_lock_app
               timeout-minutes: 10
               run: |
-                  scripts/examples/openiotsdk_example.sh -b ${{ matrix.cryptoBackend }} lock-app
+                  scripts/examples/openiotsdk_example.sh lock-app
                   .environment/pigweed-venv/bin/python3 scripts/tools/memory/gh_sizes.py \
                     openiotsdk release lock-app \
                     examples/lock-app/openiotsdk/build/chip-openiotsdk-lock-app-example.elf \
@@ -114,7 +109,7 @@
               id: build_unit_tests
               timeout-minutes: 10
               run: |
-                  scripts/examples/openiotsdk_example.sh -b ${{ matrix.cryptoBackend }} unit-tests
+                  scripts/examples/openiotsdk_example.sh unit-tests
 
             - name: "Test: shell example"
               if: steps.build_shell.outcome == 'success'
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index bb0c8ba..8516b5b 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -251,7 +251,6 @@
                 "-Cbuild",
                 "-d${input:openiotsdkDebugMode}",
                 "-l${input:openiotsdkLwipDebug}",
-                "-b${input:openiotsdkCryptoBackend}",
                 "${input:openiotsdkExample}"
             ],
             "group": "build",
@@ -272,7 +271,6 @@
                 "-Cbuild",
                 "-d${input:openiotsdkDebugMode}",
                 "-l${input:openiotsdkLwipDebug}",
-                "-b${input:openiotsdkCryptoBackend}",
                 "unit-tests"
             ],
             "group": "build",
@@ -483,13 +481,6 @@
             "default": "false"
         },
         {
-            "type": "pickString",
-            "id": "openiotsdkCryptoBackend",
-            "description": "Which Crypto algorithm do you wish to use?",
-            "options": ["mbedtls", "psa"],
-            "default": "mbedtls"
-        },
-        {
             "type": "command",
             "id": "openiotsdkExample",
             "command": "shellCommand.execute",
diff --git a/config/openiotsdk/CMakeLists.txt b/config/openiotsdk/CMakeLists.txt
index 43f9fca..7f55958 100644
--- a/config/openiotsdk/CMakeLists.txt
+++ b/config/openiotsdk/CMakeLists.txt
@@ -62,7 +62,6 @@
 matter_add_gn_arg_bool  ("chip_error_logging"                   CONFIG_CHIP_ERROR_LOGGING)
 matter_add_gn_arg_bool  ("chip_openiotsdk_use_tfm"              TFM_SUPPORT)
 matter_add_gn_arg_bool  ("chip_openiotsdk_use_psa_ps"           CONFIG_CHIP_OPEN_IOT_SDK_USE_PSA_PS)
-matter_add_gn_arg_string("chip_crypto"                          "${CONFIG_CHIP_CRYPTO}")
 if (TARGET cmsis-rtos-api)
     matter_add_gn_arg_string("target_os"                        "cmsis-rtos")
 endif()
diff --git a/config/openiotsdk/chip-gn/args.gni b/config/openiotsdk/chip-gn/args.gni
index 12ffb66..fd9edf9 100644
--- a/config/openiotsdk/chip-gn/args.gni
+++ b/config/openiotsdk/chip-gn/args.gni
@@ -31,6 +31,7 @@
 lwip_platform = "external"
 chip_system_config_use_sockets = false
 
+chip_crypto = "mbedtls"
 chip_external_mbedtls = true
 
 custom_toolchain = "${chip_root}/config/openiotsdk/chip-gn/toolchain:openiotsdk"
diff --git a/config/openiotsdk/cmake/chip.cmake b/config/openiotsdk/cmake/chip.cmake
index 6e1a78b..bdef587 100644
--- a/config/openiotsdk/cmake/chip.cmake
+++ b/config/openiotsdk/cmake/chip.cmake
@@ -21,7 +21,7 @@
 
 get_filename_component(GEN_DIR ${CHIP_ROOT}/zzz_generated/ REALPATH)
 
-# Default CHIP build configuration
+# Default CHIP build configuration 
 set(CONFIG_CHIP_PROJECT_CONFIG "main/include/CHIPProjectConfig.h" CACHE STRING "")
 set(CONFIG_CHIP_LIB_TESTS NO CACHE BOOL "")
 set(CONFIG_CHIP_LIB_SHELL NO CACHE BOOL "")
@@ -32,7 +32,6 @@
 set(CONFIG_CHIP_ERROR_LOGGING YES CACHE BOOL "Enable logging at error level")
 
 set(CONFIG_CHIP_OPEN_IOT_SDK_USE_PSA_PS NO CACHE BOOL "Enable using PSA Protected Storage")
-set(CONFIG_CHIP_CRYPTO "mbedtls" CACHE STRING "Matter crypto backend. Mbedtls as default")
 
 if(CONFIG_CHIP_OPEN_IOT_SDK_USE_PSA_PS AND NOT TFM_SUPPORT)
     message( FATAL_ERROR "You can not use PSA Protected Storage without TF-M support" )
@@ -54,14 +53,8 @@
     add_dependencies(chip-gn tfm-ns-interface)
 endif()
 
-if ("${CONFIG_CHIP_CRYPTO}" STREQUAL "psa")
-    target_compile_definitions(chip
-        INTERFACE
-            CONFIG_CHIP_CRYPTO_PSA)
-endif()
-
 function(chip_add_data_model target scope model_name)
-    target_include_directories(${target}
+    target_include_directories(${target} 
         PUBLIC
             ${GEN_DIR}/app-common
             ${GEN_DIR}/${model_name}-app
diff --git a/config/openiotsdk/cmake/sdk.cmake b/config/openiotsdk/cmake/sdk.cmake
index 6f391bd..61cd704 100644
--- a/config/openiotsdk/cmake/sdk.cmake
+++ b/config/openiotsdk/cmake/sdk.cmake
@@ -27,7 +27,7 @@
 # Open IoT SDK targets passed to CHIP build
 list(APPEND CONFIG_CHIP_EXTERNAL_TARGETS)
 
-# Additional Open IoT SDK build configuration
+# Additional Open IoT SDK build configuration 
 set(TFM_SUPPORT NO CACHE BOOL "Add Trusted Firmware-M (TF-M) support to application")
 set(TFM_NS_APP_VERSION "0.0.0" CACHE STRING "TF-M non-secure application version (in the x.x.x format)")
 set(CONFIG_CHIP_OPEN_IOT_SDK_LWIP_DEBUG NO CACHE BOOL "Enable LwIP debug logs")
@@ -82,7 +82,7 @@
     set(TFM_PLATFORM ${OPEN_IOT_SDK_EXAMPLE_COMMON}/tf-m/targets/an552)
     set(TFM_PSA_FIRMWARE_UPDATE ON)
     set(MCUBOOT_IMAGE_VERSION_NS ${TFM_NS_APP_VERSION})
-    set(TFM_CMAKE_ARGS "-DCONFIG_TFM_ENABLE_FP=ON;-DTFM_PROFILE=profile_medium;-DTFM_EXCEPTION_INFO_DUMP=ON;-DCONFIG_TFM_HALT_ON_CORE_PANIC=ON;-DTFM_ISOLATION_LEVEL=1;-DTFM_MBEDCRYPTO_PLATFORM_EXTRA_CONFIG_PATH=${OPEN_IOT_SDK_CONFIG}/mbedtls/mbedtls_config_psa.h;-DMBEDCRYPTO_BUILD_TYPE=${CMAKE_BUILD_TYPE};-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+    set(TFM_CMAKE_ARGS "-DCONFIG_TFM_ENABLE_FP=ON;-DTFM_PROFILE=profile_medium;-DTFM_EXCEPTION_INFO_DUMP=ON;-DCONFIG_TFM_HALT_ON_CORE_PANIC=ON;-DTFM_ISOLATION_LEVEL=1")
     if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
         set(TFM_CMAKE_ARGS "${TFM_CMAKE_ARGS};-DMCUBOOT_LOG_LEVEL=INFO;-DTFM_SPM_LOG_LEVEL=TFM_SPM_LOG_LEVEL_DEBUG;-DTFM_PARTITION_LOG_LEVEL=TFM_PARTITION_LOG_LEVEL_INFO")
     else()
@@ -117,24 +117,24 @@
 # Add RTOS configuration headers
 # Link cmsis-rtos-api against a concrete implementation
 if(TARGET cmsis-rtos-api)
-    target_include_directories(cmsis-core
-        INTERFACE
+    target_include_directories(cmsis-core 
+        INTERFACE 
             cmsis-config
     )
-
+    
     target_compile_definitions(cmsis-rtos-api
         PUBLIC
             DOMAIN_NS=$<IF:$<BOOL:${TFM_SUPPORT}>,1,0>
     )
 
     if(TARGET freertos-kernel)
-        target_include_directories(freertos-kernel
-            PUBLIC
+        target_include_directories(freertos-kernel 
+            PUBLIC 
                 freertos-config
         )
 
-        target_link_libraries(freertos-kernel
-            PUBLIC
+        target_link_libraries(freertos-kernel 
+            PUBLIC 
                 cmsis-core
         )
 
@@ -250,6 +250,14 @@
     )
 endif()
 
+if("mbedtls" IN_LIST IOTSDK_FETCH_LIST)
+    list(APPEND CONFIG_CHIP_EXTERNAL_TARGETS
+        mbedtls
+        mbedtls-config
+        mbedtls-threading-cmsis-rtos 
+    )
+endif()
+
 if("lwip" IN_LIST IOTSDK_FETCH_LIST)
     list(APPEND CONFIG_CHIP_EXTERNAL_TARGETS
         lwipcore
@@ -274,15 +282,6 @@
     )
 endif()
 
-# Note: Mbed TLS must appear after TF-M otherwise psa from mbed TLS is used
-if("mbedtls" IN_LIST IOTSDK_FETCH_LIST)
-    list(APPEND CONFIG_CHIP_EXTERNAL_TARGETS
-        mbedtls
-        mbedtls-config
-        mbedtls-threading-cmsis-rtos
-    )
-endif()
-
 # Additional Open IoT SDK port components
 
 # Add Open IoT SDK storage source
diff --git a/config/openiotsdk/lwip/user_lwipopts.h b/config/openiotsdk/lwip/user_lwipopts.h
index 1e02add..48d8d4a 100644
--- a/config/openiotsdk/lwip/user_lwipopts.h
+++ b/config/openiotsdk/lwip/user_lwipopts.h
@@ -49,11 +49,6 @@
  */
 #define LWIP_RAW (1)
 
-/**
- * Disable DHCP as the IP6 link local address can be used.
- */
-#define LWIP_DHCP 0
-
 #ifdef LWIP_DEBUG
 
 // Debug Options
diff --git a/config/openiotsdk/mbedtls/mbedtls_config.h b/config/openiotsdk/mbedtls/mbedtls_config.h
index b5927a0..316d43c 100644
--- a/config/openiotsdk/mbedtls/mbedtls_config.h
+++ b/config/openiotsdk/mbedtls/mbedtls_config.h
@@ -2692,7 +2692,7 @@
  *           or MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG.
  *
  */
-//#define MBEDTLS_PSA_CRYPTO_C
+#define MBEDTLS_PSA_CRYPTO_C
 
 /**
  * \def MBEDTLS_PSA_CRYPTO_SE_C
@@ -3313,8 +3313,8 @@
 //#define MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT      384 /**< Maximum size of (re)seed buffer */
 
 /* ECP options */
-#define MBEDTLS_ECP_WINDOW_SIZE 6       /**< Maximum window size used */
-#define MBEDTLS_ECP_FIXED_POINT_OPTIM 1 /**< Enable fixed-point speed-up */
+//#define MBEDTLS_ECP_WINDOW_SIZE            4 /**< Maximum window size used */
+//#define MBEDTLS_ECP_FIXED_POINT_OPTIM      1 /**< Enable fixed-point speed-up */
 
 /* Entropy options */
 //#define MBEDTLS_ENTROPY_MAX_SOURCES                20 /**< Maximum number of sources supported */
diff --git a/config/openiotsdk/mbedtls/mbedtls_config_psa.h b/config/openiotsdk/mbedtls/mbedtls_config_psa.h
deleted file mode 100644
index c7241ba..0000000
--- a/config/openiotsdk/mbedtls/mbedtls_config_psa.h
+++ /dev/null
@@ -1,6 +0,0 @@
-
-#define MBEDTLS_SHA1_C
-#define PSA_WANT_ALG_SHA_1
-#define MBEDTLS_ECP_WINDOW_SIZE 6 /**< Maximum window size used */
-#undef MBEDTLS_ECP_FIXED_POINT_OPTIM
-#define MBEDTLS_ECP_FIXED_POINT_OPTIM 1 /**< Enable fixed-point speed-up */
diff --git a/docs/guides/openiotsdk_examples.md b/docs/guides/openiotsdk_examples.md
index add3313..2de1915 100644
--- a/docs/guides/openiotsdk_examples.md
+++ b/docs/guides/openiotsdk_examples.md
@@ -374,42 +374,6 @@
 [Open IoT SDK build script](../../scripts/examples/openiotsdk_example.sh)
 provides the `-K,--kvsfile` option to use the persistence options listed above.
 
-### Crypto backend
-
-Open IoT SDK port supports two crypto backend implementations:
-
--   [Mbed TLS](../guides/openiotsdk_platform_overview.md#mbed-tls) - it's the
-    default option
--   [PSA crypto service](https://tf-m-user-guide.trustedfirmware.org/integration_guide/services/tfm_crypto_integration_guide.html)
-    from the
-    [TrustedFirmware-M (TF-M)](../guides/openiotsdk_platform_overview.md#trusted-firmware-m)
-    component
-
-The CMake variable `CONFIG_CHIP_CRYPTO` controls how cryptographic operations
-are implemented in Matter. It accepts two values:
-
--   `mbedtls`: use Mbed TLS for crypto operations.
--   `psa`: use
-    [PSA Cryptography API](https://armmbed.github.io/mbed-crypto/html/) for
-    crypto operations.
-
-This variable can be set in the main application `CMakeLists.txt`:
-
-```
-set(CONFIG_CHIP_CRYPTO <mbedtls | psa>)
-```
-
-The variable can also be defined with CMake CLI:
-
-```
-cmake -G <...> -DCONFIG_CHIP_CRYPTO=<mbedtls | psa> <...>
-```
-
-> 💡 **Notes**:
->
-> The `TF-M PSA crypto` option requires enabling [TF-M](#trusted-firmware-m)
-> support.
-
 ## Building
 
 You can build examples using the dedicated VSCode task or by calling directly
@@ -422,7 +386,6 @@
 -   Select `Build Open IoT SDK example`
 -   Decide on debug mode support
 -   Decide on LwIP debug logs support
--   Choose crypto algorithm
 -   Choose example name
 
 This will call the script with the selected parameters.
@@ -605,12 +568,12 @@
 
 ## Specific examples
 
-### Build lock-app example with PSA crypto backend support and run it in the network namespace
+### Build lock-app example and run it in the network namespace
 
 **Using CLI**
 
 ```
-${MATTER_ROOT}/scripts/examples/openiotsdk_example.sh -b psa lock-app
+${MATTER_ROOT}/scripts/examples/openiotsdk_example.sh lock-app
 
 export TEST_NETWORK_NAME=OIStest
 
@@ -630,7 +593,6 @@
 -   Select `Build Open IoT SDK example`
 -   Deny debug mode support `false`
 -   Deny LwIP debug logs support `false`
--   Choose crypto algorithm `psa`
 -   Choose example name `lock-app`
 
 Setup network environment:
@@ -652,12 +614,12 @@
 
 The example output should be seen in the terminal window.
 
-### Build lock-app example with mbedtls crypto backend support and execute its test in the network namespace
+### Build lock-app example and execute its test in the network namespace
 
 **Using CLI**
 
 ```
-${MATTER_ROOT}/scripts/examples/openiotsdk_example.sh -b mbedtls lock-app
+${MATTER_ROOT}/scripts/examples/openiotsdk_example.sh lock-app
 
 export TEST_NETWORK_NAME=OIStest
 
@@ -677,7 +639,6 @@
 -   Select `Build Open IoT SDK example`
 -   Deny debug mode support `false`
 -   Deny LwIP debug logs support `false`
--   Choose crypto algorithm `mbedtls`
 -   Choose example name `lock-app`
 
 Setup network environment:
@@ -697,7 +658,7 @@
 -   Enter network interface `OIStesttap`
 -   Choose example name `lock-app`
 
-### Build lock-app example with mbedtls crypto backend support in debug mode and debug it in the network namespace using the VSCode task
+### Build lock-app example in debug mode and debug it in the network namespace using the VSCode task
 
 Build example:
 
@@ -706,7 +667,6 @@
 -   Select `Build Open IoT SDK example`
 -   Confirm debug mode support `true`
 -   Deny LwIP debug logs support `false`
--   Choose crypto algorithm `mbedtls`
 -   Choose example name `lock-app`
 
 Setup network environment:
@@ -797,7 +757,7 @@
     id: build_new_example
     timeout-minutes: 10
     run: |
-        scripts/examples/openiotsdk_example.sh -b ${{ matrix.cryptoBackend }} new-example
+        scripts/examples/openiotsdk_example.sh new-example
         .environment/pigweed-venv/bin/python3 scripts/tools/memory/gh_sizes.py \
         openiotsdk release new-example \
         examples/new-example/openiotsdk/build/chip-openiotsdk-new-example-example.elf \
diff --git a/examples/platform/openiotsdk/app/openiotsdk_platform.cpp b/examples/platform/openiotsdk/app/openiotsdk_platform.cpp
index dff6a15..28b6da9 100644
--- a/examples/platform/openiotsdk/app/openiotsdk_platform.cpp
+++ b/examples/platform/openiotsdk/app/openiotsdk_platform.cpp
@@ -27,10 +27,6 @@
 #include "iotsdk/ip_network_api.h"
 #include "mbedtls/platform.h"
 
-#ifdef CONFIG_CHIP_CRYPTO_PSA
-#include "psa/crypto.h"
-#endif
-
 #include <DeviceInfoProviderImpl.h>
 #include <lib/support/CHIPMem.h>
 #include <lib/support/logging/CHIPLogging.h>
@@ -183,15 +179,6 @@
         return EXIT_FAILURE;
     }
 
-#ifdef CONFIG_CHIP_CRYPTO_PSA
-    ret = psa_crypto_init();
-    if (ret)
-    {
-        ChipLogError(NotSpecified, "PSA crypto initialization failed: %d", ret);
-        return EXIT_FAILURE;
-    }
-#endif
-
 #ifdef TFM_SUPPORT
     ret = get_psa_images_details();
     if (ret != 0)
diff --git a/scripts/build/BUILD.gn b/scripts/build/BUILD.gn
index 0e716ae..11ea4e9 100644
--- a/scripts/build/BUILD.gn
+++ b/scripts/build/BUILD.gn
@@ -31,8 +31,8 @@
     "testdata/dry_run_linux-arm64-ota-requestor-nodeps-ipv6only.txt",
     "testdata/dry_run_linux-x64-all-clusters-coverage.txt",
     "testdata/dry_run_nrf-nrf52840dk-pump.txt",
-    "testdata/dry_run_openiotsdk-lock-mbedtls.txt",
-    "testdata/dry_run_openiotsdk-shell-mbedtls.txt",
+    "testdata/dry_run_openiotsdk-lock.txt",
+    "testdata/dry_run_openiotsdk-shell.txt",
   ]
 
   sources = [
diff --git a/scripts/build/build/targets.py b/scripts/build/build/targets.py
index 43eed69..279191e 100755
--- a/scripts/build/build/targets.py
+++ b/scripts/build/build/targets.py
@@ -28,7 +28,7 @@
 from builders.mbed import MbedApp, MbedBoard, MbedBuilder, MbedProfile
 from builders.mw320 import MW320App, MW320Builder
 from builders.nrf import NrfApp, NrfBoard, NrfConnectBuilder
-from builders.openiotsdk import OpenIotSdkApp, OpenIotSdkBuilder, OpenIotSdkCryptoBackend
+from builders.openiotsdk import OpenIotSdkApp, OpenIotSdkBuilder
 from builders.qpg import QpgApp, QpgBoard, QpgBuilder
 from builders.telink import TelinkApp, TelinkBoard, TelinkBuilder
 from builders.ti import TIApp, TIBoard, TIBuilder
@@ -679,10 +679,6 @@
         TargetPart('lock', app=OpenIotSdkApp.LOCK),
     ])
 
-    # Modifiers
-    target.AppendModifier('mbedtls', crypto=OpenIotSdkCryptoBackend.MBEDTLS).ExceptIfRe('-(psa)')
-    target.AppendModifier('psa', crypto=OpenIotSdkCryptoBackend.PSA).ExceptIfRe('-(mbedtls)')
-
     return target
 
 
diff --git a/scripts/build/builders/openiotsdk.py b/scripts/build/builders/openiotsdk.py
index 89aad6a..7f3cd68 100644
--- a/scripts/build/builders/openiotsdk.py
+++ b/scripts/build/builders/openiotsdk.py
@@ -42,29 +42,13 @@
             raise Exception('Unknown app type: %r' % self)
 
 
-class OpenIotSdkCryptoBackend(Enum):
-    PSA = auto()
-    MBEDTLS = auto()
-
-    @property
-    def CryptoBackendName(self):
-        if self == OpenIotSdkCryptoBackend.PSA:
-            return 'psa'
-        elif self == OpenIotSdkCryptoBackend.MBEDTLS:
-            return 'mbedtls'
-        else:
-            raise Exception('Unknown crypto backend type: %r' % self)
-
-
 class OpenIotSdkBuilder(Builder):
     def __init__(self,
                  root,
                  runner,
-                 app: OpenIotSdkApp = OpenIotSdkApp.SHELL,
-                 crypto: OpenIotSdkCryptoBackend = OpenIotSdkCryptoBackend.MBEDTLS):
+                 app: OpenIotSdkApp = OpenIotSdkApp.SHELL):
         super(OpenIotSdkBuilder, self).__init__(root, runner)
         self.app = app
-        self.crypto = crypto
         self.toolchain_path = os.path.join(
             'toolchains', 'toolchain-arm-none-eabi-gcc.cmake')
         self.system_processor = 'cortex-m55'
@@ -81,8 +65,6 @@
                            '-DCMAKE_SYSTEM_PROCESSOR={}'.format(
                                self.system_processor),
                            '-DCMAKE_BUILD_TYPE=Release',
-                           '-DCONFIG_CHIP_CRYPTO={}'.format(
-                               self.crypto.CryptoBackendName),
                            ], title='Generating ' + self.identifier)
 
     def _build(self):
diff --git a/scripts/build/test.py b/scripts/build/test.py
index c89a4d9..70fca73 100644
--- a/scripts/build/test.py
+++ b/scripts/build/test.py
@@ -109,8 +109,8 @@
             'android-arm64-chip-tool',
             'nrf-nrf52840dk-pump',
             'efr32-brd4161a-light-rpc-no-version',
-            'openiotsdk-lock-mbedtls',
-            'openiotsdk-shell-mbedtls'
+            'openiotsdk-lock',
+            'openiotsdk-shell'
         ]
 
         for target in TARGETS:
diff --git a/scripts/build/testdata/all_targets_linux_x64.txt b/scripts/build/testdata/all_targets_linux_x64.txt
index 5ef536a..1b8c95d 100644
--- a/scripts/build/testdata/all_targets_linux_x64.txt
+++ b/scripts/build/testdata/all_targets_linux_x64.txt
@@ -22,4 +22,4 @@
 qpg-qpg6105-{lock,light,shell,persistent-storage}
 tizen-arm-{all-clusters,all-clusters-minimal,chip-tool,light,tests}[-no-ble][-no-thread][-no-wifi][-asan][-ubsan]
 telink-tlsr9518adk80d-{all-clusters,all-clusters-minimal,bridge,contact-sensor,light,light-switch,lock,ota-requestor,pump,pump-controller,temperature-measurement,thermostat,window-covering}[-shell][-rpc][-factory-data]
-openiotsdk-{shell,lock}[-mbedtls][-psa]
+openiotsdk-{shell,lock}
diff --git a/scripts/build/testdata/dry_run_openiotsdk-lock-mbedtls.txt b/scripts/build/testdata/dry_run_openiotsdk-lock-mbedtls.txt
deleted file mode 100644
index 77816cf..0000000
--- a/scripts/build/testdata/dry_run_openiotsdk-lock-mbedtls.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-# Commands will be run in CHIP project root.
-cd "{root}"
-
-# Generating openiotsdk-lock-mbedtls
-cmake -GNinja -S {root}/examples/lock-app/openiotsdk -B {out}/openiotsdk-lock-mbedtls --toolchain=toolchains/toolchain-arm-none-eabi-gcc.cmake -DCMAKE_SYSTEM_PROCESSOR=cortex-m55 -DCMAKE_BUILD_TYPE=Release -DCONFIG_CHIP_CRYPTO=mbedtls
-
-# Building openiotsdk-lock-mbedtls
-cmake --build {out}/openiotsdk-lock-mbedtls
diff --git a/scripts/build/testdata/dry_run_openiotsdk-lock.txt b/scripts/build/testdata/dry_run_openiotsdk-lock.txt
new file mode 100644
index 0000000..a0c36ee
--- /dev/null
+++ b/scripts/build/testdata/dry_run_openiotsdk-lock.txt
@@ -0,0 +1,8 @@
+# Commands will be run in CHIP project root.
+cd "{root}"
+
+# Generating openiotsdk-lock
+cmake -GNinja -S {root}/examples/lock-app/openiotsdk -B {out}/openiotsdk-lock --toolchain=toolchains/toolchain-arm-none-eabi-gcc.cmake -DCMAKE_SYSTEM_PROCESSOR=cortex-m55 -DCMAKE_BUILD_TYPE=Release
+
+# Building openiotsdk-lock
+cmake --build {out}/openiotsdk-lock
diff --git a/scripts/build/testdata/dry_run_openiotsdk-shell-mbedtls.txt b/scripts/build/testdata/dry_run_openiotsdk-shell-mbedtls.txt
deleted file mode 100644
index 70438c5..0000000
--- a/scripts/build/testdata/dry_run_openiotsdk-shell-mbedtls.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-# Commands will be run in CHIP project root.
-cd "{root}"
-
-# Generating openiotsdk-shell-mbedtls
-cmake -GNinja -S {root}/examples/shell/openiotsdk -B {out}/openiotsdk-shell-mbedtls --toolchain=toolchains/toolchain-arm-none-eabi-gcc.cmake -DCMAKE_SYSTEM_PROCESSOR=cortex-m55 -DCMAKE_BUILD_TYPE=Release -DCONFIG_CHIP_CRYPTO=mbedtls
-
-# Building openiotsdk-shell-mbedtls
-cmake --build {out}/openiotsdk-shell-mbedtls
diff --git a/scripts/build/testdata/dry_run_openiotsdk-shell.txt b/scripts/build/testdata/dry_run_openiotsdk-shell.txt
new file mode 100644
index 0000000..6c7c63b
--- /dev/null
+++ b/scripts/build/testdata/dry_run_openiotsdk-shell.txt
@@ -0,0 +1,8 @@
+# Commands will be run in CHIP project root.
+cd "{root}"
+
+# Generating openiotsdk-shell
+cmake -GNinja -S {root}/examples/shell/openiotsdk -B {out}/openiotsdk-shell --toolchain=toolchains/toolchain-arm-none-eabi-gcc.cmake -DCMAKE_SYSTEM_PROCESSOR=cortex-m55 -DCMAKE_BUILD_TYPE=Release
+
+# Building openiotsdk-shell
+cmake --build {out}/openiotsdk-shell
diff --git a/scripts/examples/openiotsdk_example.sh b/scripts/examples/openiotsdk_example.sh
index 1f3dcd1..6b19a8b 100755
--- a/scripts/examples/openiotsdk_example.sh
+++ b/scripts/examples/openiotsdk_example.sh
@@ -43,7 +43,6 @@
 FVP_NETWORK="user"
 KVS_STORAGE_TYPE="tdb"
 KVS_STORAGE_FILE=""
-CRYPTO_BACKEND="mbedtls"
 
 declare -A tdb_storage_param=([instance]=sram [memspace]=0 [address]=0x0 [size]=0x100000)
 declare -A ps_storage_param=([instance]=qspi_sram [memspace]=0 [address]=0x660000 [size]=0x12000)
@@ -67,7 +66,6 @@
     -d,--debug      <debug_enable>      Build in debug mode <true | false - default>
     -l,--lwipdebug  <lwip_debug_enable> Build with LwIP debug logs support <true | false - default>
     -k,--kvsstore   <kvs_storage_type>  Select KVS storage type <ps | tdb - default>
-    -b,--backend    <crypto_backend)    Select crypto backend <psa | mbedtls - default>
     -p,--path       <build_path>        Build path <build_path - default is example_dir/build>
     -K,--kvsfile    <kvs_storage_file>  Path to KVS storage file which will be used to ensure persistence <kvs_storage_file - default is empty which means disable persistence>
     -n,--network    <network_name>      FVP network interface name <network_name - default is "user" which means user network mode>
@@ -136,8 +134,6 @@
         BUILD_OPTIONS+=(-DCONFIG_CHIP_OPEN_IOT_SDK_USE_PSA_PS=YES)
     fi
 
-    BUILD_OPTIONS+=(-DCONFIG_CHIP_CRYPTO="$CRYPTO_BACKEND")
-
     cmake -G Ninja -S "$EXAMPLE_PATH" -B "$BUILD_PATH" --toolchain="$TOOLCHAIN_PATH" "${BUILD_OPTIONS[@]}"
     cmake --build "$BUILD_PATH"
 }
@@ -272,8 +268,8 @@
     fi
 }
 
-SHORT=C:,p:,d:,l:,b:,n:,k:,K:,c,s,h
-LONG=command:,path:,debug:,lwipdebug:,backend:,network:,kvsstore:,kvsfile:,clean,scratch,help
+SHORT=C:,p:,d:,l:,n:,k:,K:,c,s,h
+LONG=command:,path:,debug:,lwipdebug:,network:,kvsstore:,kvsfile:,clean,scratch,help
 OPTS=$(getopt -n build --options "$SHORT" --longoptions "$LONG" -- "$@")
 
 eval set -- "$OPTS"
@@ -312,10 +308,6 @@
             KVS_STORAGE_FILE=$2
             shift 2
             ;;
-        -b | --backend)
-            CRYPTO_BACKEND=$2
-            shift 2
-            ;;
         -p | --path)
             BUILD_PATH=$CHIP_ROOT/$2
             shift 2
@@ -388,15 +380,6 @@
         ;;
 esac
 
-case "$CRYPTO_BACKEND" in
-    psa | mbedtls) ;;
-    *)
-        echo "Wrong crypto type definition"
-        show_usage
-        exit 2
-        ;;
-esac
-
 TOOLCHAIN_PATH="toolchains/toolchain-$TOOLCHAIN.cmake"
 
 if [ -z "$BUILD_PATH" ]; then
