Add key_demo with modifying from storage TAkey_api_demo

Signed-off-by: Jun Nie <jun.nie@linaro.org>

13 files changed, 1327 insertions, 1 deletions

diff --git a/host/xtest/Makefile b/host/xtest/Makefile
index 8505629..b432570 100644
--- a/host/xtest/Makefile
+++ b/host/xtest/Makefile
@@ -169,7 +169,10 @@ LDFLAGS += -lpthread -lm
 all: xtest
 
 xtest: $(objs)
-	@echo "  LD      $(out-dir)/xtest/$@"
+	echo "  LD      $(out-dir)/xtest/$@"
+	echo "========== client path: ${OPTEE_CLIENT_EXPORT}" > /tmp/clientpath
+	echo "========== cflags: ${CFLAGS} \n ldflags $(LDFLAGS)" > /tmp/flags
+	$(error client path: ${OPTEE_CLIENT_EXPORT})
 	$(q)$(CC) -o $(out-dir)/xtest/$@ $+ $(LDFLAGS)
 
 $(out-dir)/xtest/%.o: $(CURDIR)/%.c
diff --git a/host/xtest/regression_4000.c b/host/xtest/regression_4000.c
index 505c981..6b43592 100644
--- a/host/xtest/regression_4000.c
+++ b/host/xtest/regression_4000.c
@@ -17,6 +17,7 @@
 #include <tee_api_defines_extensions.h>
 #include <tee_api_compat.h>
 #include <ta_crypt.h>
+#include <ta_key_demo.h>
 #include <utee_defines.h>
 #include <util.h>
 
@@ -6165,3 +6166,85 @@ out:
 }
 ADBG_CASE_DEFINE(regression, 4016, xtest_tee_test_4016_ed25519,
 		 "Test TEE Internal API ED25519 sign/verify");
+
+static void xtest_tee_test_4017_single(ADBG_Case_t *c)
+{
+	TEEC_Session sess;
+	uint32_t orig;
+	TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
+	char key1_id[] = "aeskey#1";		/* string identification for the key */
+
+	if (!ADBG_EXPECT_TEEC_SUCCESS(c,
+		xtest_teec_open_session(&sess, &key_demo_ta_uuid, NULL, &orig)))
+		return;
+
+	op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_MEMREF_TEMP_INPUT,
+					 TEEC_NONE, TEEC_NONE);
+
+	op.params[0].value.a = TEE_TYPE_AES;
+	op.params[0].value.b = AES_KEY_SIZE_256;
+
+	op.params[1].tmpref.buffer = key1_id;
+	op.params[1].tmpref.size = strlen(key1_id);
+
+	ADBG_EXPECT_TEEC_SUCCESS(c,
+		TEEC_InvokeCommand(&sess, TA_KEY_DEMO_CMD_CREATE_KEY,
+				   &op, &orig));
+
+	TEEC_CloseSession(&sess);
+}
+ADBG_CASE_DEFINE(regression, 4017, xtest_tee_test_4017_single,
+		 "Key creation in Persistent objects");
+
+
+static void xtest_tee_test_4018_single(ADBG_Case_t *c)
+{
+	TEEC_Session sess;
+	uint32_t orig;
+	TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
+	char key1_id[] = "aeskey#1";		/* string identification for the key */
+
+	if (!ADBG_EXPECT_TEEC_SUCCESS(c,
+		xtest_teec_open_session(&sess, &key_demo_ta_uuid, NULL, &orig)))
+		return;
+
+	op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_NONE,
+					 TEEC_NONE, TEEC_NONE);
+
+	op.params[0].tmpref.buffer = key1_id;
+	op.params[0].tmpref.size = strlen(key1_id);
+
+	ADBG_EXPECT_TEEC_SUCCESS(c,
+		TEEC_InvokeCommand(&sess, TA_KEY_DEMO_CMD_FIND,
+				   &op, &orig));
+
+	TEEC_CloseSession(&sess);
+}
+ADBG_CASE_DEFINE(regression, 4018, xtest_tee_test_4018_single,
+		 "Key demo object find in Persistent objects");
+
+static void xtest_tee_test_4019_single(ADBG_Case_t *c)
+{
+	TEEC_Session sess;
+	uint32_t orig;
+	TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
+	char key1_id[] = "aeskey#1";		/* string identification for the key */
+
+	if (!ADBG_EXPECT_TEEC_SUCCESS(c,
+		xtest_teec_open_session(&sess, &key_demo_ta_uuid, NULL, &orig)))
+		return;
+
+	op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_NONE,
+					 TEEC_NONE, TEEC_NONE);
+
+	op.params[0].tmpref.buffer = key1_id;
+	op.params[0].tmpref.size = strlen(key1_id);
+
+	ADBG_EXPECT_TEEC_SUCCESS(c,
+		TEEC_InvokeCommand(&sess, TA_KEY_DEMO_CMD_DELETE,
+				   &op, &orig));
+
+	TEEC_CloseSession(&sess);
+}
+ADBG_CASE_DEFINE(regression, 4019, xtest_tee_test_4019_single,
+		 "Key deletion in Persistent objects");
diff --git a/host/xtest/xtest_test.c b/host/xtest/xtest_test.c
index 7beecff..e5d1bb1 100644
--- a/host/xtest/xtest_test.c
+++ b/host/xtest/xtest_test.c
@@ -20,6 +20,7 @@
 #include <ta_socket.h>
 #include <ta_storage_benchmark.h>
 #include <ta_storage.h>
+#include <ta_key_demo.h>
 #include <ta_supp_plugin.h>
 #include <ta_tpm_log_test.h>
 #include <ta_arm_bti.h>
@@ -194,6 +195,7 @@ const TEEC_UUID miss_test_ta_uuid = TA_MISS_TEST_UUID;
 const TEEC_UUID sims_keepalive_test_ta_uuid = TA_SIMS_KEEP_ALIVE_TEST_UUID;
 const TEEC_UUID storage_ta_uuid = TA_STORAGE_UUID;
 const TEEC_UUID storage2_ta_uuid = TA_STORAGE2_UUID;
+const TEEC_UUID key_demo_ta_uuid = TA_KEY_DEMO_UUID;
 const TEEC_UUID enc_fs_key_manager_test_ta_uuid = ENC_FS_KEY_MANAGER_TEST_UUID;
 const TEEC_UUID concurrent_ta_uuid = TA_CONCURRENT_UUID;
 const TEEC_UUID concurrent_large_ta_uuid = TA_CONCURRENT_LARGE_UUID;
diff --git a/host/xtest/xtest_test.h b/host/xtest/xtest_test.h
index 50fc2b5..1f2f352 100644
--- a/host/xtest/xtest_test.h
+++ b/host/xtest/xtest_test.h
@@ -126,6 +126,7 @@ extern const TEEC_UUID gp_tta_check_OpenSession_with_4_parameters_uuid;
 extern const TEEC_UUID gp_tta_ds_uuid;
 extern const TEEC_UUID storage_ta_uuid;
 extern const TEEC_UUID storage2_ta_uuid;
+extern const TEEC_UUID key_demo_ta_uuid;
 extern const TEEC_UUID enc_fs_key_manager_test_ta_uuid;
 extern const TEEC_UUID ecc_test_ta_uuid;
 extern const TEEC_UUID pta_invoke_tests_ta_uuid;
diff --git a/ta/Makefile b/ta/Makefile
index 33ed949..5bab282 100644
--- a/ta/Makefile
+++ b/ta/Makefile
@@ -30,6 +30,7 @@ TA_DIRS := create_fail_test \
 	   storage_benchmark \
 	   hash_perf \
 	   aes_perf \
+	   key_demo \
 	   socket \
 	   supp_plugin \
 	   large \
diff --git a/ta/include/ta_key_demo.h b/ta/include/ta_key_demo.h
new file mode 100644
index 0000000..6e100d1
--- /dev/null
+++ b/ta/include/ta_key_demo.h
@@ -0,0 +1,59 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+/*
+ * Copyright (c) 2014, STMicroelectronics International N.V.
+ * All rights reserved.
+ */
+
+#ifndef __TA_KEY_DEMO_H
+#define __TA_KEY_DEMO_H
+
+#define TA_KEY_DEMO_UUID { 0xc689f2a7, 0x8adf, 0x477a, \
+	{ 0x9f, 0x99, 0x32, 0xe9, 0x0c, 0x0a, 0xd0, 0xa2 } }
+
+struct ta_key_demo_obj_info {
+	uint32_t object_type;
+	uint32_t object_size;
+	uint32_t max_object_size;
+	uint32_t object_usage;
+	uint32_t data_size;
+	uint32_t data_position;
+	uint32_t handle_flags;
+};
+
+typedef enum {
+	AES_KEY_SIZE_128 = (128 / 8),
+	AES_KEY_SIZE_192 = (192 / 8),
+	AES_KEY_SIZE_256 = (256 / 8),
+} aes_key_size_t;
+
+#define TA_KEY_DEMO_CMD_OPEN			0
+#define TA_KEY_DEMO_CMD_CLOSE			1
+#define TA_KEY_DEMO_CMD_READ			2
+#define TA_KEY_DEMO_CMD_WRITE			3
+#define TA_KEY_DEMO_CMD_CREATE			4
+#define TA_KEY_DEMO_CMD_SEEK			5
+#define TA_KEY_DEMO_CMD_UNLINK			6
+#define TA_KEY_DEMO_CMD_RENAME			7
+#define TA_KEY_DEMO_CMD_TRUNC			8
+#define TA_KEY_DEMO_CMD_ALLOC_ENUM		9
+#define TA_KEY_DEMO_CMD_FREE_ENUM		10
+#define TA_KEY_DEMO_CMD_RESET_ENUM		11
+#define TA_KEY_DEMO_CMD_START_ENUM		12
+#define TA_KEY_DEMO_CMD_NEXT_ENUM		13
+#define TA_KEY_DEMO_CMD_CREATE_OVERWRITE		14
+#define TA_KEY_DEMO_CMD_KEY_IN_PERSISTENT	15
+#define TA_KEY_DEMO_CMD_LOOP			16
+#define TA_KEY_DEMO_CMD_RESTRICT_USAGE		17
+#define TA_KEY_DEMO_CMD_ALLOC_OBJ		18
+#define TA_KEY_DEMO_CMD_FREE_OBJ			19
+#define TA_KEY_DEMO_CMD_RESET_OBJ		20
+#define TA_KEY_DEMO_CMD_GET_OBJ_INFO		21
+#define TA_KEY_DEMO_CMD_OPEN_ID_IN_SHM		22
+#define TA_KEY_DEMO_CMD_CREATE_ID_IN_SHM		23
+#define TA_KEY_DEMO_CMD_CREATEOVER_ID_IN_SHM	24
+#define TA_KEY_DEMO_CMD_RENAME_ID_IN_SHM		25
+#define TA_KEY_DEMO_CMD_CREATE_KEY			26
+#define TA_KEY_DEMO_CMD_FIND				27
+#define TA_KEY_DEMO_CMD_DELETE				28
+
+#endif /*__TA_KEY_DEMO_H*/
diff --git a/ta/key_demo/Android.mk b/ta/key_demo/Android.mk
new file mode 100644
index 0000000..d638f95
--- /dev/null
+++ b/ta/key_demo/Android.mk
@@ -0,0 +1,4 @@
+LOCAL_PATH := $(call my-dir)
+
+local_module := c689f2a7-8adf-477a-9f99-32e90c0ad0a2.ta
+include $(BUILD_OPTEE_MK)
diff --git a/ta/key_demo/Makefile b/ta/key_demo/Makefile
new file mode 100644
index 0000000..7fff27d
--- /dev/null
+++ b/ta/key_demo/Makefile
@@ -0,0 +1,2 @@
+BINARY = c689f2a7-8adf-477a-9f99-32e90c0ad0a2
+include ../ta_common.mk
diff --git a/ta/key_demo/include/key_demo.h b/ta/key_demo/include/key_demo.h
new file mode 100644
index 0000000..4bac02b
--- /dev/null
+++ b/ta/key_demo/include/key_demo.h
@@ -0,0 +1,48 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+/*
+ * Copyright (c) 2014, STMicroelectronics International N.V.
+ * All rights reserved.
+ */
+
+#ifndef KEY_DEMO_H
+#define KEY_DEMO_H
+
+#include <tee_api.h>
+
+#define KEY_DEMO_STORAGE TEE_STORAGE_PRIVATE
+
+TEE_Result ta_key_demo_cmd_open(uint32_t command, uint32_t param_types,
+						 TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_create(uint32_t command, uint32_t param_types,
+						   TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_create_overwrite(uint32_t command,
+					   uint32_t param_types,
+					   TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_close(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_read(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_write(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_seek(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_unlink(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_rename(uint32_t command, uint32_t param_types,
+						   TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_trunc(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_alloc_enum(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_free_enum(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_reset_enum(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_start_enum(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_next_enum(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_key_in_persistent(uint32_t param_types,
+					    TEE_Param params[4]);
+TEE_Result ta_key_demo_create_key(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_find(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_delete(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_loop(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_restrict_usage(uint32_t param_types,
+					 TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_alloc_obj(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_free_obj(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_reset_obj(uint32_t param_types, TEE_Param params[4]);
+TEE_Result ta_key_demo_cmd_get_obj_info(uint32_t param_types,
+					    TEE_Param params[4]);
+
+#endif /*KEY_DEMO_H */
diff --git a/ta/key_demo/include/user_ta_header_defines.h b/ta/key_demo/include/user_ta_header_defines.h
new file mode 100644
index 0000000..fbf472a
--- /dev/null
+++ b/ta/key_demo/include/user_ta_header_defines.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2014, STMicroelectronics International N.V.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef USER_TA_HEADER_DEFINES_H
+#define USER_TA_HEADER_DEFINES_H
+
+#include <ta_key_demo.h>
+
+#define TA_UUID TA_KEY_DEMO_UUID
+
+/*
+ * This is important to have TA_FLAG_SINGLE_INSTANCE && !TA_FLAG_MULTI_SESSION
+ * as it is used by the ytest
+ */
+#define TA_FLAGS		(TA_FLAG_USER_MODE | TA_FLAG_EXEC_DDR | \
+				TA_FLAG_MULTI_SESSION)
+#define TA_STACK_SIZE		(2 * 1024)
+#define TA_DATA_SIZE		(32 * 1024)
+
+#endif
diff --git a/ta/key_demo/key_demo.c b/ta/key_demo/key_demo.c
new file mode 100644
index 0000000..bab27c8
--- /dev/null
+++ b/ta/key_demo/key_demo.c
@@ -0,0 +1,917 @@
+// SPDX-License-Identifier: BSD-2-Clause
+/*
+ * Copyright (c) 2014, STMicroelectronics International N.V.
+ * All rights reserved.
+ */
+
+#include "key_demo.h"
+#include "ta_key_demo.h"
+
+#include <tee_api.h>
+#include <trace.h>
+
+#define ASSERT_PARAM_TYPE(pt) \
+do { \
+	if ((pt) != param_types) \
+		return TEE_ERROR_BAD_PARAMETERS; \
+} while (0)
+
+#define VAL2HANDLE(v) (void *)(uintptr_t)(v)
+
+#if 0
+TEE_Result ta_key_demo_cmd_open(uint32_t command,
+				uint32_t param_types, TEE_Param params[4])
+{
+	TEE_Result res = TEE_ERROR_GENERIC;
+	TEE_ObjectHandle o = TEE_HANDLE_NULL;
+	void *object_id = NULL;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_MEMREF_INPUT,
+			   TEE_PARAM_TYPE_VALUE_INOUT,
+			   TEE_PARAM_TYPE_VALUE_INPUT,
+			   TEE_PARAM_TYPE_NONE));
+
+	switch (command) {
+	case TA_KEY_DEMO_CMD_OPEN:
+		if (params[0].memref.buffer) {
+			object_id = TEE_Malloc(params[0].memref.size, 0);
+			if (!object_id)
+				return TEE_ERROR_OUT_OF_MEMORY;
+
+			TEE_MemMove(object_id, params[0].memref.buffer,
+				    params[0].memref.size);
+		}
+		break;
+	case TA_KEY_DEMO_CMD_OPEN_ID_IN_SHM:
+		object_id = params[0].memref.buffer;
+		break;
+	default:
+		return TEE_ERROR_NOT_SUPPORTED;
+	}
+
+	res = TEE_OpenPersistentObject(params[2].value.a,
+					object_id, params[0].memref.size,
+					params[1].value.a, &o);
+
+	params[1].value.b = (uintptr_t)o;
+
+	if (command == TA_KEY_DEMO_CMD_OPEN)
+		TEE_Free(object_id);
+
+	return res;
+}
+
+TEE_Result ta_key_demo_cmd_create(uint32_t command,
+				 uint32_t param_types, TEE_Param params[4])
+{
+	TEE_Result res = TEE_ERROR_GENERIC;
+	TEE_ObjectHandle o = TEE_HANDLE_NULL;
+	void *object_id = NULL;
+	TEE_ObjectHandle ref_handle = TEE_HANDLE_NULL;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_MEMREF_INPUT,
+			   TEE_PARAM_TYPE_VALUE_INOUT,
+			   TEE_PARAM_TYPE_VALUE_INPUT,
+			   TEE_PARAM_TYPE_MEMREF_INPUT));
+
+	switch (command) {
+	case TA_KEY_DEMO_CMD_CREATE:
+		if (params[0].memref.buffer) {
+			object_id = TEE_Malloc(params[0].memref.size, 0);
+			if (!object_id)
+				return TEE_ERROR_OUT_OF_MEMORY;
+
+			TEE_MemMove(object_id, params[0].memref.buffer,
+				    params[0].memref.size);
+		}
+		break;
+	case TA_KEY_DEMO_CMD_CREATE_ID_IN_SHM:
+		object_id = params[0].memref.buffer;
+		break;
+	default:
+		return TEE_ERROR_NOT_SUPPORTED;
+	}
+
+	ref_handle = (TEE_ObjectHandle)(uintptr_t)params[2].value.a;
+
+	res = TEE_CreatePersistentObject(params[2].value.b,
+					 object_id, params[0].memref.size,
+					 params[1].value.a, ref_handle,
+					 params[3].memref.buffer,
+					 params[3].memref.size, &o);
+
+	if (command == TA_KEY_DEMO_CMD_CREATE)
+		TEE_Free(object_id);
+
+	params[1].value.b = (uintptr_t)o;
+
+	return res;
+}
+
+TEE_Result ta_key_demo_cmd_create_overwrite(uint32_t command,
+					   uint32_t param_types,
+					   TEE_Param params[4])
+{
+	TEE_Result res = TEE_ERROR_GENERIC;
+	TEE_ObjectHandle o = TEE_HANDLE_NULL;
+	void *object_id = NULL;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_MEMREF_INPUT,
+			   TEE_PARAM_TYPE_VALUE_INPUT,
+			   TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE));
+
+	switch (command) {
+	case TA_KEY_DEMO_CMD_CREATE_OVERWRITE:
+		object_id = TEE_Malloc(params[0].memref.size, 0);
+		if (!object_id)
+			return TEE_ERROR_OUT_OF_MEMORY;
+
+		TEE_MemMove(object_id, params[0].memref.buffer,
+			    params[0].memref.size);
+		break;
+	case TA_KEY_DEMO_CMD_CREATEOVER_ID_IN_SHM:
+		object_id = params[0].memref.buffer;
+		break;
+	default:
+		return TEE_ERROR_NOT_SUPPORTED;
+	}
+
+	res = TEE_CreatePersistentObject(params[1].value.a,
+					 object_id, params[0].memref.size,
+					 TEE_DATA_FLAG_OVERWRITE,
+					 NULL, NULL, 0, &o);
+	TEE_CloseObject(o);
+
+	if (command == TA_KEY_DEMO_CMD_CREATE_OVERWRITE)
+		TEE_Free(object_id);
+
+	return res;
+}
+
+TEE_Result ta_key_demo_cmd_close(uint32_t param_types, TEE_Param params[4])
+{
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	TEE_CloseObject((TEE_ObjectHandle)(uintptr_t)params[0].value.a);
+
+	return TEE_SUCCESS;
+}
+
+TEE_Result ta_key_demo_cmd_read(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectHandle o = VAL2HANDLE(params[1].value.a);
+	TEE_Result res = TEE_SUCCESS;
+	size_t sz = 0;
+	void *b0 = NULL;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_MEMREF_OUTPUT,
+			   TEE_PARAM_TYPE_VALUE_INOUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE));
+
+	b0 = TEE_Malloc(params[0].memref.size, 0);
+	if (!b0)
+		return TEE_ERROR_OUT_OF_MEMORY;
+
+	sz = params[1].value.b;
+	res = TEE_ReadObjectData(o, b0, params[0].memref.size, &sz);
+	params[1].value.b = sz;
+	if (!res)
+		TEE_MemMove(params[0].memref.buffer, b0, params[0].memref.size);
+	TEE_Free(b0);
+
+	return res;
+}
+
+TEE_Result ta_key_demo_cmd_write(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectHandle o = VAL2HANDLE(params[1].value.a);
+	TEE_Result res = TEE_SUCCESS;
+	void *b0 = NULL;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_MEMREF_INPUT,
+			   TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE));
+
+	b0 = TEE_Malloc(params[0].memref.size, 0);
+	if (!b0)
+		return TEE_ERROR_OUT_OF_MEMORY;
+	TEE_MemMove(b0, params[0].memref.buffer, params[0].memref.size);
+
+	res = TEE_WriteObjectData(o, b0, params[0].memref.size);
+	TEE_Free(b0);
+
+	return res;
+}
+
+TEE_Result ta_key_demo_cmd_seek(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_Result res = TEE_ERROR_GENERIC;
+	TEE_ObjectInfo info;
+	TEE_ObjectHandle o = VAL2HANDLE(params[0].value.a);
+	int32_t offs = 0;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT,
+			   TEE_PARAM_TYPE_VALUE_INOUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE));
+
+	offs = *(int32_t *)&params[0].value.b;
+	res = TEE_SeekObjectData(o, offs, params[1].value.a);
+	if (res != TEE_SUCCESS)
+		return res;
+	res = TEE_GetObjectInfo1(o, &info);
+
+	params[1].value.b = info.dataPosition;
+
+	return res;
+}
+
+TEE_Result ta_key_demo_cmd_unlink(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectHandle o = VAL2HANDLE(params[0].value.a);
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	TEE_CloseAndDeletePersistentObject1(o);
+
+	return TEE_SUCCESS;
+}
+
+TEE_Result ta_key_demo_cmd_rename(uint32_t command, uint32_t param_types,
+				 TEE_Param params[4])
+{
+	TEE_ObjectHandle o = VAL2HANDLE(params[0].value.a);
+	void *object_id = NULL;
+	TEE_Result res = TEE_ERROR_GENERIC;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT,
+			   TEE_PARAM_TYPE_MEMREF_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE));
+
+	switch (command) {
+	case TA_KEY_DEMO_CMD_RENAME:
+		if (params[0].memref.buffer) {
+			object_id = TEE_Malloc(params[1].memref.size, 0);
+			if (!object_id)
+				return TEE_ERROR_OUT_OF_MEMORY;
+
+			TEE_MemMove(object_id, params[1].memref.buffer,
+				    params[1].memref.size);
+		}
+		break;
+	case TA_KEY_DEMO_CMD_RENAME_ID_IN_SHM:
+		object_id = params[1].memref.buffer;
+		break;
+	default:
+		return TEE_ERROR_NOT_SUPPORTED;
+	}
+
+	res = TEE_RenamePersistentObject(o, object_id, params[1].memref.size);
+
+	if (command == TA_KEY_DEMO_CMD_RENAME)
+		TEE_Free(object_id);
+
+	return res;
+}
+
+TEE_Result ta_key_demo_cmd_trunc(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectHandle o = VAL2HANDLE(params[0].value.a);
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	return TEE_TruncateObjectData(o, params[0].value.b);
+}
+
+TEE_Result ta_key_demo_cmd_alloc_enum(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_Result res = TEE_ERROR_GENERIC;
+	TEE_ObjectEnumHandle oe = TEE_HANDLE_NULL;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_OUTPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	res = TEE_AllocatePersistentObjectEnumerator(&oe);
+	params[0].value.a = (uintptr_t)oe;
+	return res;
+}
+
+TEE_Result ta_key_demo_cmd_free_enum(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectEnumHandle oe = VAL2HANDLE(params[0].value.a);
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	TEE_FreePersistentObjectEnumerator(oe);
+	return TEE_SUCCESS;
+}
+
+TEE_Result ta_key_demo_cmd_reset_enum(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectEnumHandle oe = VAL2HANDLE(params[0].value.a);
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	TEE_ResetPersistentObjectEnumerator(oe);
+	return TEE_SUCCESS;
+}
+
+TEE_Result ta_key_demo_cmd_start_enum(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectEnumHandle oe = VAL2HANDLE(params[0].value.a);
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	return TEE_StartPersistentObjectEnumerator(oe, params[0].value.b);
+}
+
+TEE_Result ta_key_demo_cmd_next_enum(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectEnumHandle oe = VAL2HANDLE(params[0].value.a);
+	TEE_Result res = TEE_SUCCESS;
+	TEE_ObjectInfo *obj = NULL;
+	void *b2 = NULL;
+
+	if (TEE_PARAM_TYPE_GET(param_types, 0) != TEE_PARAM_TYPE_VALUE_INPUT)
+		return TEE_ERROR_BAD_PARAMETERS;
+	if (TEE_PARAM_TYPE_GET(param_types, 2) != TEE_PARAM_TYPE_MEMREF_OUTPUT)
+		return TEE_ERROR_BAD_PARAMETERS;
+	if (TEE_PARAM_TYPE_GET(param_types, 3) != TEE_PARAM_TYPE_NONE)
+		return TEE_ERROR_BAD_PARAMETERS;
+
+	if (params[2].memref.size < TEE_OBJECT_ID_MAX_LEN)
+		return TEE_ERROR_SHORT_BUFFER;
+
+	if (TEE_PARAM_TYPE_GET(param_types, 1) == TEE_PARAM_TYPE_NONE)
+		obj = NULL;
+	else if (TEE_PARAM_TYPE_GET(param_types, 1) ==
+		 TEE_PARAM_TYPE_MEMREF_OUTPUT) {
+		if (params[1].memref.size < sizeof(TEE_ObjectInfo)) {
+			params[1].memref.size = sizeof(TEE_ObjectInfo);
+			return TEE_ERROR_SHORT_BUFFER;
+		}
+		params[1].memref.size = sizeof(TEE_ObjectInfo);
+		obj = TEE_Malloc(sizeof(TEE_ObjectInfo), 0);
+		if (!obj)
+			return TEE_ERROR_OUT_OF_MEMORY;
+	} else
+		return TEE_ERROR_BAD_PARAMETERS;
+
+	b2 = TEE_Malloc(params[2].memref.size, 0);
+	if (!b2) {
+		res = TEE_ERROR_OUT_OF_MEMORY;
+		goto out;
+	}
+
+	res = TEE_GetNextPersistentObject(oe, obj, b2, &params[2].memref.size);
+	if (res)
+		goto out;
+
+	TEE_MemMove(params[2].memref.buffer, b2, params[2].memref.size);
+	if (obj)
+		TEE_MemMove(params[1].memref.buffer, obj, sizeof(*obj));
+out:
+	TEE_Free(b2);
+	TEE_Free(obj);
+
+	return res;
+}
+#endif
+
+static TEE_Result check_obj(TEE_ObjectInfo *o1, TEE_ObjectInfo *o2)
+{
+	if ((o1->objectType != o2->objectType) ||
+	    (o1->objectSize != o2->objectSize) ||
+	    (o1->maxObjectSize != o2->maxObjectSize) ||
+	    (o1->objectUsage != o2->objectUsage))
+		return TEE_ERROR_GENERIC;
+	return TEE_SUCCESS;
+}
+
+#if 0
+TEE_Result ta_key_demo_cmd_key_in_persistent(uint32_t param_types,
+					    TEE_Param params[4])
+{
+	TEE_Result result = TEE_SUCCESS;
+	TEE_ObjectHandle transient_key = TEE_HANDLE_NULL;
+	TEE_ObjectHandle persistent_key = TEE_HANDLE_NULL;
+	TEE_ObjectHandle key = TEE_HANDLE_NULL;
+	TEE_OperationHandle encrypt_op = TEE_HANDLE_NULL;
+	TEE_ObjectInfo keyInfo;
+	TEE_ObjectInfo keyInfo2;
+	TEE_ObjectInfo keyInfo3;
+	uint32_t alg = TEE_ALG_AES_CBC_NOPAD;
+	void *IV = NULL;
+	size_t IVlen = 16;
+	size_t key_size = 256;
+	uint32_t objectID = 1;
+	uint32_t flags = TEE_DATA_FLAG_ACCESS_READ |
+			 TEE_DATA_FLAG_ACCESS_WRITE |
+			 TEE_DATA_FLAG_ACCESS_WRITE_META |
+			 TEE_DATA_FLAG_SHARE_READ |
+			 TEE_DATA_FLAG_SHARE_WRITE;
+
+	TEE_MemFill(&keyInfo, 0, sizeof(keyInfo));
+	TEE_MemFill(&keyInfo2, 0, sizeof(keyInfo2));
+	TEE_MemFill(&keyInfo3, 0, sizeof(keyInfo3));
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	result = TEE_AllocateTransientObject(TEE_TYPE_AES, key_size,
+					     &transient_key);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to Allocate transient object handle : 0x%x",
+		     result);
+		goto cleanup1;
+	}
+
+	result = TEE_GenerateKey(transient_key, key_size, NULL, 0);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to generate a transient key: 0x%x", result);
+		goto cleanup2;
+	}
+
+	TEE_GetObjectInfo1(transient_key, &keyInfo);
+	result = TEE_CreatePersistentObject(params[0].value.a,
+					    &objectID, sizeof(objectID),
+					    flags, transient_key, NULL, 0,
+					    &persistent_key);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to create a persistent key: 0x%x", result);
+		goto cleanup2;
+	}
+
+	TEE_GetObjectInfo1(persistent_key, &keyInfo2);
+	result = check_obj(&keyInfo, &keyInfo2);
+	if (result != TEE_SUCCESS) {
+		EMSG("keyInfo and keyInfo2 are different");
+		goto cleanup2;
+	}
+
+	TEE_CloseAndDeletePersistentObject1(persistent_key);
+
+	/* Transform the transient object into a persistent object */
+	result = TEE_CreatePersistentObject(params[0].value.a,
+					    &objectID, sizeof(objectID),
+					    flags, transient_key, NULL, 0,
+					    NULL);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to create a persistent key: 0x%x", result);
+		goto cleanup2;
+	}
+	persistent_key = transient_key;
+	transient_key = TEE_HANDLE_NULL;
+
+	TEE_GetObjectInfo1(persistent_key, &keyInfo2);
+	result = check_obj(&keyInfo, &keyInfo2);
+	if (result != TEE_SUCCESS) {
+		EMSG("keyInfo and keyInfo2 are different");
+		goto cleanup2;
+	}
+
+	TEE_CloseObject(persistent_key);
+
+	result = TEE_OpenPersistentObject(params[0].value.a,
+					  &objectID, sizeof(objectID),
+					  flags, &key);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to open persistent key: 0x%x", result);
+		goto cleanup2;
+	}
+
+	TEE_GetObjectInfo(key, &keyInfo3);
+	result = check_obj(&keyInfo3, &keyInfo2);
+	if (result != TEE_SUCCESS) {
+		EMSG("keyInfo2 and keyInfo3 are different");
+		goto cleanup2;
+	}
+
+	result = TEE_AllocateOperation(&encrypt_op, alg, TEE_MODE_ENCRYPT,
+				       keyInfo3.maxObjectSize);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to allocate an operation: 0x%x", result);
+		goto cleanup3;
+	}
+
+	result = TEE_SetOperationKey(encrypt_op, key);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to set operation key: 0x%x", result);
+		goto cleanup4;
+	}
+
+	IV = TEE_Malloc(IVlen, 0);
+	if (!IV) {
+		EMSG("Out of memory for IV.");
+		result = TEE_ERROR_OUT_OF_MEMORY;
+		goto cleanup4;
+	}
+
+	TEE_CipherInit(encrypt_op, IV, IVlen);
+	TEE_Free(IV);
+
+cleanup4:
+	TEE_FreeOperation(encrypt_op);
+cleanup3:
+	TEE_CloseAndDeletePersistentObject1(key);
+cleanup2:
+	TEE_FreeTransientObject(transient_key);
+cleanup1:
+	return result;
+}
+#endif
+
+static TEE_Result ta2tee_key_size(uint32_t param, uint32_t *key_size)
+{
+	switch (param) {
+	case AES_KEY_SIZE_128:
+	case AES_KEY_SIZE_192:
+	case AES_KEY_SIZE_256:
+		*key_size = param;
+		return TEE_SUCCESS;
+	default:
+		EMSG("Invalid key size %u", param);
+		return TEE_ERROR_BAD_PARAMETERS;
+	}
+}
+
+#define TEST_CRYPT_SIZE 512
+static char in_buf[TEST_CRYPT_SIZE];
+static char out_buf[TEST_CRYPT_SIZE];
+
+TEE_Result ta_key_demo_create_key(uint32_t param_types,
+					    TEE_Param params[4])
+{
+	TEE_Result result = TEE_SUCCESS;
+	TEE_ObjectHandle transient_key = TEE_HANDLE_NULL;
+	TEE_ObjectHandle persistent_key = TEE_HANDLE_NULL;
+	TEE_ObjectHandle key = TEE_HANDLE_NULL;
+	TEE_OperationHandle encrypt_op = TEE_HANDLE_NULL;
+	TEE_ObjectInfo keyInfo;
+	TEE_ObjectInfo keyInfo2;
+	TEE_ObjectInfo keyInfo3;
+	uint32_t alg = TEE_ALG_AES_CBC_NOPAD;
+	uint32_t storage_id = KEY_DEMO_STORAGE;
+	void *IV = NULL;
+	size_t IVlen = 16;
+	size_t key_type;
+	size_t key_size;
+	size_t key_id_sz;
+	char *key_id;
+	uint32_t flags = TEE_DATA_FLAG_ACCESS_READ |
+			 TEE_DATA_FLAG_ACCESS_WRITE |
+			 TEE_DATA_FLAG_ACCESS_WRITE_META |
+			 TEE_DATA_FLAG_SHARE_READ |
+			 TEE_DATA_FLAG_SHARE_WRITE;
+
+	TEE_MemFill(&keyInfo, 0, sizeof(keyInfo));
+	TEE_MemFill(&keyInfo2, 0, sizeof(keyInfo2));
+	TEE_MemFill(&keyInfo3, 0, sizeof(keyInfo3));
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_MEMREF_INPUT,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	result = ta2tee_key_size(params[0].value.b, &key_size);
+	if (result != TEE_SUCCESS)
+		return result;
+
+	key_type = params[0].value.a;
+	key_id_sz = params[1].memref.size;
+	key_id = TEE_Malloc(key_id_sz, 0);
+	if (!key_id)
+		return TEE_ERROR_OUT_OF_MEMORY;
+
+	TEE_MemMove(key_id, params[1].memref.buffer, key_id_sz);
+
+	result = TEE_AllocateTransientObject(key_type, key_size * 8,
+					     &transient_key);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to Allocate transient object handle : 0x%x",
+		     result);
+		goto cleanup1;
+	}
+
+	result = TEE_GenerateKey(transient_key, key_size * 8, NULL, 0);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to generate a transient key: 0x%x", result);
+		goto cleanup2;
+	}
+
+	TEE_GetObjectInfo1(transient_key, &keyInfo);
+	result = TEE_CreatePersistentObject(storage_id,
+					    key_id, key_id_sz,
+					    flags, transient_key, NULL, 0,
+					    &persistent_key);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to create a persistent key: 0x%x", result);
+		goto cleanup2;
+	}
+
+	TEE_GetObjectInfo1(persistent_key, &keyInfo2);
+	result = check_obj(&keyInfo, &keyInfo2);
+	if (result != TEE_SUCCESS) {
+		EMSG("keyInfo and keyInfo2 are different");
+		goto cleanup2;
+	}
+
+	TEE_FreeTransientObject(transient_key);
+	transient_key = TEE_HANDLE_NULL;
+	TEE_CloseObject(persistent_key);
+
+	result = TEE_OpenPersistentObject(storage_id,
+					  key_id, key_id_sz,
+					  flags, &key);
+EMSG("-----------Open persistent object, res=0x%08x", result);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to open persistent key: 0x%x", result);
+		goto cleanup2;
+	}
+
+	TEE_GetObjectInfo(key, &keyInfo3);
+	result = check_obj(&keyInfo3, &keyInfo2);
+	if (result != TEE_SUCCESS) {
+		EMSG("keyInfo2 and keyInfo3 are different");
+		goto cleanup2;
+	}
+
+	result = TEE_AllocateOperation(&encrypt_op, alg, TEE_MODE_ENCRYPT,
+				       keyInfo3.maxObjectSize);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to allocate an operation: 0x%x", result);
+		goto cleanup3;
+	}
+
+	result = TEE_SetOperationKey(encrypt_op, key);
+	if (result != TEE_SUCCESS) {
+		EMSG("Failed to set operation key: 0x%x", result);
+		goto cleanup4;
+	}
+
+	IV = TEE_Malloc(IVlen, 0);
+	if (!IV) {
+		EMSG("Out of memory for IV.");
+		result = TEE_ERROR_OUT_OF_MEMORY;
+		goto cleanup4;
+	}
+
+	TEE_CipherInit(encrypt_op, IV, IVlen);
+
+
+	TEE_MemFill(in_buf, 0xc5, TEST_CRYPT_SIZE);
+#if 0
+	/* we see panic in TEE_CipherUpdate() */
+	TEE_CipherUpdate(encrypt_op,
+			in_buf, TEST_CRYPT_SIZE,
+			out_buf, TEST_CRYPT_SIZE);
+#endif
+
+	EMSG("========Out buf [0] 0x%x [28] 0x%x.", out_buf[0], out_buf[28]);
+	TEE_Free(IV);
+
+cleanup4:
+	TEE_FreeOperation(encrypt_op);
+	encrypt_op = TEE_HANDLE_NULL;
+cleanup3:
+	//TEE_CloseAndDeletePersistentObject1(key);
+cleanup2:
+	TEE_FreeTransientObject(transient_key);
+cleanup1:
+	return result;
+}
+
+TEE_Result ta_key_demo_find(uint32_t param_types,
+				  TEE_Param params[4])
+{
+	uint32_t storageID = KEY_DEMO_STORAGE;
+	char *key_id;
+	size_t key_id_sz;
+	TEE_Result res = TEE_SUCCESS;
+	TEE_ObjectHandle object;
+	TEE_ObjectInfo object_info;
+
+EMSG("=========enter %s, res=0x%08x", __func__, res);
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_MEMREF_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	key_id_sz = params[0].memref.size;
+	key_id = TEE_Malloc(key_id_sz, 0);
+	if (!key_id)
+		return TEE_ERROR_OUT_OF_MEMORY;
+
+	TEE_MemMove(key_id, params[0].memref.buffer, key_id_sz);
+
+	/*
+	 * Check the object exist and can be dumped into output buffer
+	 * then dump it.
+	 */
+	res = TEE_OpenPersistentObject(storageID,
+					key_id, key_id_sz,
+					TEE_DATA_FLAG_ACCESS_READ |
+					TEE_DATA_FLAG_SHARE_READ,
+					&object);
+EMSG("=========Open persistent object %s, res=0x%08x", key_id, res);
+	if (res != TEE_SUCCESS) {
+		EMSG("Failed to open persistent object, res=0x%08x", res);
+		TEE_Free(key_id);
+		return res;
+	}
+
+	res = TEE_GetObjectInfo1(object, &object_info);
+	if (res != TEE_SUCCESS) {
+		EMSG("Failed to get persistent object, res=0x%08x", res);
+	}
+
+	TEE_CloseObject(object);
+	TEE_Free(key_id);
+	return res;
+}
+
+TEE_Result ta_key_demo_delete(uint32_t param_types,
+			      TEE_Param params[4])
+{
+	uint32_t storageID = KEY_DEMO_STORAGE;
+	char *key_id;
+	size_t key_id_sz;
+	TEE_Result res = TEE_SUCCESS;
+	TEE_ObjectHandle object;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_MEMREF_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	key_id_sz = params[0].memref.size;
+	key_id = TEE_Malloc(key_id_sz, 0);
+	if (!key_id)
+		return TEE_ERROR_OUT_OF_MEMORY;
+
+	TEE_MemMove(key_id, params[0].memref.buffer, key_id_sz);
+
+	/*
+	 * Check the object exist and can be dumped into output buffer
+	 * then dump it.
+	 */
+	res = TEE_OpenPersistentObject(storageID,
+					key_id, key_id_sz,
+					TEE_DATA_FLAG_ACCESS_READ |
+					TEE_DATA_FLAG_ACCESS_WRITE_META, /* we must be allowed to delete it */
+					&object);
+	if (res != TEE_SUCCESS) {
+		EMSG("Failed to open persistent object, res=0x%08x", res);
+		TEE_Free(key_id);
+		return res;
+	}
+
+	TEE_CloseAndDeletePersistentObject1(object);
+	TEE_Free(key_id);
+	return res;
+}
+
+TEE_Result ta_key_demo_cmd_loop(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectHandle object = TEE_HANDLE_NULL;
+	TEE_Result res = TEE_ERROR_GENERIC;
+	int object_id = 0;
+	uint32_t flags =  TEE_DATA_FLAG_OVERWRITE |
+			  TEE_DATA_FLAG_ACCESS_WRITE_META;
+	int i = 0;
+
+	(void)params;
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	for (i = 0; i < 20; i++) {
+		DMSG("\n\nLOOP : %d", i);
+		object = TEE_HANDLE_NULL;
+		object_id = i;
+		res = TEE_CreatePersistentObject(params[0].value.a,
+						 &object_id, sizeof(int), flags,
+						 TEE_HANDLE_NULL, NULL, 0,
+						 &object);
+
+		if (res != TEE_SUCCESS) {
+			EMSG("FAIL");
+			return res;
+		}
+
+		res = TEE_CloseAndDeletePersistentObject1(object);
+		if (res != TEE_SUCCESS) {
+			EMSG("FAIL");
+			return res;
+		}
+	}
+
+	return TEE_SUCCESS;
+}
+
+#if 0
+TEE_Result ta_key_demo_cmd_restrict_usage(uint32_t param_types,
+					 TEE_Param params[4])
+{
+	TEE_ObjectHandle o = TEE_HANDLE_NULL;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	o = (TEE_ObjectHandle)(uintptr_t)params[0].value.a;
+	TEE_RestrictObjectUsage1(o, params[0].value.b);
+	return TEE_SUCCESS;
+}
+
+TEE_Result ta_key_demo_cmd_alloc_obj(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_Result res = TEE_ERROR_GENERIC;
+	TEE_ObjectHandle o = TEE_HANDLE_NULL;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT,
+			   TEE_PARAM_TYPE_VALUE_OUTPUT,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	res = TEE_AllocateTransientObject(params[0].value.a, params[0].value.b,
+					  &o);
+	params[1].value.a = (uint32_t)(uintptr_t)o;
+	return res;
+}
+
+TEE_Result ta_key_demo_cmd_free_obj(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectHandle o = TEE_HANDLE_NULL;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	o = (TEE_ObjectHandle)(uintptr_t)params[0].value.a;
+	TEE_FreeTransientObject(o);
+	return TEE_SUCCESS;
+}
+
+TEE_Result ta_key_demo_cmd_reset_obj(uint32_t param_types, TEE_Param params[4])
+{
+	TEE_ObjectHandle o = TEE_HANDLE_NULL;
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
+
+	o = (TEE_ObjectHandle)(uintptr_t)params[0].value.a;
+	TEE_ResetTransientObject(o);
+	return TEE_SUCCESS;
+}
+
+TEE_Result ta_key_demo_cmd_get_obj_info(uint32_t param_types,
+					    TEE_Param params[4])
+{
+	TEE_Result res = TEE_ERROR_GENERIC;
+	struct ta_key_demo_obj_info oi = { };
+	TEE_ObjectInfo info = { };
+	TEE_ObjectHandle o = VAL2HANDLE(params[0].value.a);
+
+	ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
+			  (TEE_PARAM_TYPE_VALUE_INPUT,
+			   TEE_PARAM_TYPE_MEMREF_OUTPUT, TEE_PARAM_TYPE_NONE,
+			   TEE_PARAM_TYPE_NONE));
+
+	if (params[1].memref.size < sizeof(oi))
+		return TEE_ERROR_SHORT_BUFFER;
+	res = TEE_GetObjectInfo1(o, &info);
+	if (!res) {
+		params[1].memref.size = sizeof(oi);
+		oi.object_type = info.objectType;
+		oi.object_size = info.objectSize;
+		oi.max_object_size = info.maxObjectSize;
+		oi.object_usage = info.objectUsage;
+		oi.data_size = info.dataSize;
+		oi.data_position = info.dataPosition;
+		oi.handle_flags = info.handleFlags;
+		TEE_MemMove(params[1].memref.buffer, &oi, sizeof(oi));
+	}
+
+	return res;
+}
+#endif
diff --git a/ta/key_demo/sub.mk b/ta/key_demo/sub.mk
new file mode 100644
index 0000000..db5c2d1
--- /dev/null
+++ b/ta/key_demo/sub.mk
@@ -0,0 +1,4 @@
+global-incdirs-y += include
+global-incdirs-y += ../include
+srcs-y += key_demo.c
+srcs-y += ta_entry.c
diff --git a/ta/key_demo/ta_entry.c b/ta/key_demo/ta_entry.c
new file mode 100644
index 0000000..d7f7e97
--- /dev/null
+++ b/ta/key_demo/ta_entry.c
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2014, STMicroelectronics International N.V.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <tee_ta_api.h>
+#include <ta_key_demo.h>
+
+#include "key_demo.h"
+
+/*
+ * Trusted Application Entry Points
+ */
+
+/* Called each time a new instance is created */
+TEE_Result TA_CreateEntryPoint(void)
+{
+	return TEE_SUCCESS;
+}
+
+/* Called each time an instance is destroyed */
+void TA_DestroyEntryPoint(void)
+{
+}
+
+/* Called each time a session is opened */
+TEE_Result TA_OpenSessionEntryPoint(uint32_t nParamTypes,
+				    TEE_Param pParams[4],
+				    void **ppSessionContext)
+{
+	(void)nParamTypes;
+	(void)pParams;
+	(void)ppSessionContext;
+	return TEE_SUCCESS;
+}
+
+/* Called each time a session is closed */
+void TA_CloseSessionEntryPoint(void *pSessionContext)
+{
+	(void)pSessionContext;
+}
+
+/* Called when a command is invoked */
+TEE_Result TA_InvokeCommandEntryPoint(void *pSessionContext,
+				      uint32_t nCommandID, uint32_t nParamTypes,
+				      TEE_Param pParams[4])
+{
+	(void)pSessionContext;
+
+	switch (nCommandID) {
+/*
+	case TA_KEY_DEMO_CMD_OPEN:
+	case TA_KEY_DEMO_CMD_OPEN_ID_IN_SHM:
+		return ta_key_demo_cmd_open(nCommandID, nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_CLOSE:
+		return ta_key_demo_cmd_close(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_READ:
+		return ta_key_demo_cmd_read(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_WRITE:
+		return ta_key_demo_cmd_write(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_CREATE:
+	case TA_KEY_DEMO_CMD_CREATE_ID_IN_SHM:
+		return ta_key_demo_cmd_create(nCommandID, nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_CREATE_OVERWRITE:
+	case TA_KEY_DEMO_CMD_CREATEOVER_ID_IN_SHM:
+		return ta_key_demo_cmd_create_overwrite(nCommandID, nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_SEEK:
+		return ta_key_demo_cmd_seek(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_UNLINK:
+		return ta_key_demo_cmd_unlink(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_RENAME:
+	case TA_KEY_DEMO_CMD_RENAME_ID_IN_SHM:
+		return ta_key_demo_cmd_rename(nCommandID, nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_TRUNC:
+		return ta_key_demo_cmd_trunc(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_ALLOC_ENUM:
+		return ta_key_demo_cmd_alloc_enum(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_FREE_ENUM:
+		return ta_key_demo_cmd_free_enum(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_RESET_ENUM:
+		return ta_key_demo_cmd_reset_enum(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_START_ENUM:
+		return ta_key_demo_cmd_start_enum(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_NEXT_ENUM:
+		return ta_key_demo_cmd_next_enum(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_KEY_IN_PERSISTENT:
+		return ta_key_demo_cmd_key_in_persistent(nParamTypes, pParams);
+*/
+	case TA_KEY_DEMO_CMD_CREATE_KEY:
+		return ta_key_demo_create_key(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_FIND:
+		return ta_key_demo_find(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_DELETE:
+		return ta_key_demo_delete(nParamTypes, pParams);
+
+/*
+	case TA_KEY_DEMO_CMD_LOOP:
+		return ta_key_demo_cmd_loop(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_RESTRICT_USAGE:
+		return ta_key_demo_cmd_restrict_usage(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_ALLOC_OBJ:
+		return ta_key_demo_cmd_alloc_obj(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_FREE_OBJ:
+		return ta_key_demo_cmd_free_obj(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_RESET_OBJ:
+		return ta_key_demo_cmd_reset_obj(nParamTypes, pParams);
+
+	case TA_KEY_DEMO_CMD_GET_OBJ_INFO:
+		return ta_key_demo_cmd_get_obj_info(nParamTypes, pParams);
+*/
+
+	default:
+		return TEE_ERROR_BAD_PARAMETERS;
+	}
+}