From af4aafeb01279cc095a610cf4125923df0514e2f Mon Sep 17 00:00:00 2001 From: Jinkun Jang Date: Sat, 16 Mar 2013 01:17:53 +0900 Subject: [PATCH] merge with master --- CMakeLists.txt | 32 +++++- NOTICE | 6 +- cryptsvc.pc.in | 2 +- include/SecCryptoSvc.h | 1 + include/SecTzSvc.h | 86 ++++++++++++++ include/tci.h | 54 +++++++++ include/tlc_tzcrypt.h | 112 +++++++++++++++++++ include/tltzcrypt_api.h | 84 ++++++++++++++ libs/{libShpSec.a => libDeviceInfo.a} | Bin 115496 -> 115528 bytes libs/libtzcrypt.a | Bin 0 -> 14410 bytes packaging/libcryptsvc.spec | 2 +- srcs/SecCryptoSvc.c | 179 ++++++++++++++--------------- srcs/SecTzSvc.c | 204 ++++++++++++++++++++++++++++++++++ 13 files changed, 669 insertions(+), 93 deletions(-) mode change 100644 => 100755 CMakeLists.txt create mode 100755 include/SecTzSvc.h create mode 100755 include/tci.h create mode 100755 include/tlc_tzcrypt.h create mode 100755 include/tltzcrypt_api.h rename libs/{libShpSec.a => libDeviceInfo.a} (78%) mode change 100644 => 100755 create mode 100755 libs/libtzcrypt.a mode change 100644 => 100755 packaging/libcryptsvc.spec mode change 100644 => 100755 srcs/SecCryptoSvc.c create mode 100755 srcs/SecTzSvc.c diff --git a/CMakeLists.txt b/CMakeLists.txt old mode 100644 new mode 100755 index 9a76bdd..e688dcf --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -42,7 +42,7 @@ SET(libcryptsvc_CPPFLAGS " -DPIC ") ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS}) IF("${ARCH}" MATCHES "arm") -TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS} -ldl -lssl -lcrypto -L./libs -lShpSec) +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS} -ldl -lssl -lcrypto -L./libs -lDeviceInfo) ELSEIF("${ARCH}" MATCHES "x86") TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS} -ldl -lssl -lcrypto) ENDIF("${ARCH}" MATCHES "arm") @@ -57,6 +57,35 @@ SET_TARGET_PROPERTIES( ################################################################################################################## ################################################################################################################## +# for libtzsvc.so +SET(SRCS_TZ + ${source_dir}/SecCryptoSvc.c + ${source_dir}/SecTzSvc.c +) + +SET(libtzsvc_LDFLAGS " -module -avoid-version ${pkgs_LDFLAGS} ") +SET(libtzsvc_CFLAGS " ${CFLAGS} -fvisibility=hidden -g -fPIC -I${CMAKE_CURRENT_SOURCE_DIR}/include ") +SET(libtzsvc_CPPFLAGS " -DPIC ") + +SET(LIBTZ_SO "tzsvc") +ADD_LIBRARY(${LIBTZ_SO} SHARED ${SRCS_TZ}) + +IF("${ARCH}" MATCHES "arm") +TARGET_LINK_LIBRARIES(${LIBTZ_SO} ${pkgs_LDFLAGS} -ldl -lssl -lcrypto -L./libs -lDeviceInfo) +ELSEIF("${ARCH}" MATCHES "x86") +TARGET_LINK_LIBRARIES(${LIBTZ_SO} ${pkgs_LDFLAGS} -ldl -lssl -lcrypto) +ENDIF("${ARCH}" MATCHES "arm") + +SET_TARGET_PROPERTIES( + ${LIBTZ_SO} + PROPERTIES + SOVERSION 0 + VERSION 0.0.0 +) +################################################################################################################## + + +################################################################################################################## # for module_test #SET(module_test_SOURCES #${test_dir}/module_test.c @@ -83,6 +112,7 @@ ENDIF("${ARCH}" MATCHES "arm") CONFIGURE_FILE(${PROJECT_NAME}.pc.in ${PROJECT_NAME}.pc) INSTALL(FILES ${PROJECT_NAME}.pc DESTINATION lib/pkgconfig) INSTALL(TARGETS ${PROJECT_NAME} DESTINATION lib) +INSTALL(TARGETS ${LIBTZ_SO} DESTINATION lib) INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION /usr/include) ADD_DEFINITIONS(-D_bool_cryptsvc) diff --git a/NOTICE b/NOTICE index e96466a..326d67b 100755 --- a/NOTICE +++ b/NOTICE @@ -2,5 +2,9 @@ Copyright (c) Samsung Electronics Co., Ltd. All rights reserved. Except as noted, this software is licensed under Apache License, Version 2. Please, see the LICENSE.APLv2 file for Apache License terms and conditions. -libShpSec.a file is licensed under Flora License, Version 1. +libDeviceInfo.a file is licensed under Flora License, Version 1. Please, see the LICENSE.Flora file for Flora License, Version 1 terms and conditions. + +libtzcrypt.a file is licensed under Flora License, Version 1. +Please, see the LICENSE.Flora file for Flora License, Version 1 terms and conditions. + diff --git a/cryptsvc.pc.in b/cryptsvc.pc.in index f5cf256..eb94648 100755 --- a/cryptsvc.pc.in +++ b/cryptsvc.pc.in @@ -6,6 +6,6 @@ Name: libcryptsvc Description:nothing Version: 0.0.1 Requires: openssl -Libs: -L${libdir} -lcryptsvc +Libs: -L${libdir} -lcryptsvc -ltzsvc Cflags: -I${includedir} diff --git a/include/SecCryptoSvc.h b/include/SecCryptoSvc.h index 13ef3c3..d6d4a2b 100755 --- a/include/SecCryptoSvc.h +++ b/include/SecCryptoSvc.h @@ -92,6 +92,7 @@ typedef enum {false, true} bool; //#define SEC_CRYPTP_ARR_LENGTH 1024 #define SEC_FRAME_OSP_KEY "uniqueKey" //#define SHA1_DIGEST_VALUE_LEN 20 +#define SHA256_DIGEST_VALUE_LEN 32 //#define KDF_KEYLEN 16 #define HASH_LEN 20 //#define SEC_KEYMGR_FEK_SIZE 16 diff --git a/include/SecTzSvc.h b/include/SecTzSvc.h new file mode 100755 index 0000000..ee107ea --- /dev/null +++ b/include/SecTzSvc.h @@ -0,0 +1,86 @@ +/* + * libcryptsvc - device unique key + * + * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef _SEC_TZ_SVC_H +#define _SEC_TZ_SVC_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef unsigned int uint32_t; +typedef unsigned char uint8_t; +typedef unsigned int TZCRYPT_Result; +typedef unsigned char TZCRYPT_UINT8; +typedef unsigned int TZCRYPT_UINT32; +typedef unsigned long TZCRYPT_UINT64; + +#define SHA256_DIGEST_VALUE_LEN 32 + +/* + * This function provides an encryption of user data. + * + * @param [in] Src : User data to be encrypted + * @param [in] SrcLen : Length of user data to be encrypted (multiple by chunk size, SIZE_CHUNK) + * @param [out] Dst : Encrypted data + * @param [out] *DstLen : a pointer to length of encrypted data (multiple by secure object size, SIZE_SECUREOBJECT) + * @param [in] AppInfo : Application information + * @param [in] AppInfoLen : Length of Application information + * @param [out] WrapAppInfo : Hashed and wrapped Application Information as an identifier + * @param [out] *WrapAppInfo : a pointer to length of hashed and wraped Application Information as an identifier + * + * return SEC_CRYPTO_SUCCESS if operation has been succesfully completed. (Refer to the tlc error code) + */ +__attribute__((visibility("default"))) +TZCRYPT_Result SecEncryptTZCrypt(TZCRYPT_UINT8 *Src, TZCRYPT_UINT32 SrcLen, TZCRYPT_UINT8 *Dst, TZCRYPT_UINT32 *DstLen, TZCRYPT_UINT8 *AppInfo, TZCRYPT_UINT32 AppInfoLen, TZCRYPT_UINT8 *WrapAppInfo, TZCRYPT_UINT32 *WrapAppInfoLen); + +/* + * This function provides an decryption of user data. + * + * @param [in] Src : Cipher data to be decrypted + * @param [in] SrcLen : Length of Cipher data to be decrypted (multiple by chunk size, SIZE_SECUREOBJECT) + * @param [out] Dst : Encrypted data + * @param [out] *DstLen : a pointer to length of encrypted data (multiple by secure object size, SIZE_CHUNK) + * @param [in] AppInfo : Application information + * @param [in] AppInfoLen : Length of Application information + * @param [in] WrapAppInfo : Hashed and wrapped Application Information as an identifier + * @param [in] WrapAppInfo : Length of hashed and wraped Application Information as an identifier + * + * return SEC_CRYPTO_SUCCESS if operation has been succesfully completed. (Refer to the tlc error code) + * If a given application information (identifier) is wrong, then return UNIT_TEXT_HASH_ERROR + */ +__attribute__((visibility("default"))) +TZCRYPT_Result SecDecryptTZCrypt(TZCRYPT_UINT8 *Src, TZCRYPT_UINT32 SrcLen, TZCRYPT_UINT8 *Dst, TZCRYPT_UINT32 *DstLen, TZCRYPT_UINT8 *AppInfo, TZCRYPT_UINT32 AppInfoLen, TZCRYPT_UINT8 *WrapAppInfo, TZCRYPT_UINT32 WrapAppInfoLen); + +/* + * This function provides the length of a given src len + * + * @param [in] source length + * + * return length of cipher text + */ +__attribute__((visibility("default"))) +TZCRYPT_UINT32 SecGetCipherLen(TZCRYPT_UINT32 srclen); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/tci.h b/include/tci.h new file mode 100755 index 0000000..e27984c --- /dev/null +++ b/include/tci.h @@ -0,0 +1,54 @@ +/* + * tci.h + * + * Created on: 05.05.2010 + * Author: galkag + * modified ckyu.han@samsung.com + */ + +#ifndef TCI_H_ +#define TCI_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* +typedef unsigned int uint32_t; +typedef unsigned char uint8_t; +*/ + +typedef uint32_t tciCommandId_t; +typedef uint32_t tciResponseId_t; +typedef uint32_t tciReturnCode_t; + +/* Responses have bit 31 set */ +#define RSP_ID_MASK (1U << 31) +#define RSP_ID(cmdId) (((uint32_t)(cmdId)) | RSP_ID_MASK) +#define IS_CMD(cmdId) ((((uint32_t)(cmdId)) & RSP_ID_MASK) == 0) +#define IS_RSP(cmdId) ((((uint32_t)(cmdId)) & RSP_ID_MASK) == RSP_ID_MASK) + +/* Return codes of Trustlet commands. */ +#define RET_OK 0 /* Set, if processing is error free */ +#define RET_ERR_UNKNOWN_CMD 1 /* Unknown command */ +#define RET_CUSTOM_START 2 +#define RET_ERR_MAP 3 +#define RET_ERR_UNMAP 4 + +/* TCI command header. */ +typedef struct { + tciCommandId_t commandId; /* Command ID */ +} tciCommandHeader_t; + +/* TCI response header. */ +typedef struct { + tciResponseId_t responseId; /* Response ID (must be command ID | RSP_ID_MASK )*/ + tciReturnCode_t returnCode; /* Return code of command */ +} tciResponseHeader_t; + +#ifdef __cplusplus +} +#endif + +#endif /* TCI_H_ */ diff --git a/include/tlc_tzcrypt.h b/include/tlc_tzcrypt.h new file mode 100755 index 0000000..7234cb1 --- /dev/null +++ b/include/tlc_tzcrypt.h @@ -0,0 +1,112 @@ +/* + * tlc_tzcrypto.h + * + */ + +#ifndef TLC_TZCRYPT_H_ +#define TLC_TZCRYPT_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif +/* +typedef unsigned int TZCRYPT_Result; +typedef unsigned char TZCRYPT_UINT8; +typedef unsigned int TZCRYPT_UINT32; +typedef unsigned long TZCRYPT_UINT64; +*/ + +/* TLC error code */ +#define TZCRYPT_SUCCESS 0x00000000 +#define TZCRYPT_ERROR_INIT_FAILED 0x20000001 +#define TZCRYPT_ERROR_TERMINATE_FAILED 0x20000002 +#define TZCRYPT_ERROR_ENCRYPT_FAILED 0x20000003 +#define TZCRYPT_ERROR_DECRYPT_FAILED 0x20000004 +#define TZCRYPT_ERROR_WRAPIDENTITY_FAILED 0x20000005 +#define TZCRYPT_ERROR_UNWRAPIDENTITY_FAILED 0x20000006 +#define TZCRYPT_ERROR_HASH_FAILED 0x20000007 +#define TZCRYPT_ERROR_INVALID_PARAMETER 0x20000008 + +/* Sec Crypto error code */ +#define SEC_CRYPTO_SUCCESS 0x00000000 +#define SEC_CRYPTO_ENCRYPT_ERROR 0x30000001 +#define SEC_CRYPTO_DECRYPT_ERROR 0x30000002 +#define SEC_CRYPTO_WRAPIDENTITY_ERROR 0x30000003 +#define SEC_CRYPTO_UNWRAPIDENTITY_ERROR 0x30000004 +#define SEC_CRYPTO_HASH_ERROR 0x30000005 + +/* + * This function provides an encryption of user data. + * + * @param [in] Src : User data to be encrypted + * @param [in] SrcLen : Length of user data to be encrypted (multiple by chunk size, SIZE_CHUNK) + * @param [out] Dst : Encrypted data + * @param [out] *DstLen : a pointer to length of encrypted data (multiple by secure object size, SIZE_SECUREOBJECT) + * + * return TZCRYPT_SUCCESS if operation has been succesfully completed. (Refer to the previous TLC error code) + */ +TZCRYPT_Result TzCrypt_Encrypt(TZCRYPT_UINT8 *Src, TZCRYPT_UINT32 SrcLen, TZCRYPT_UINT8 *Dst, TZCRYPT_UINT32 *DstLen); + +/* + * This function provides an decryption of user data. + * + * @param [in] Src : Cipher data to be decrypted + * @param [in] SrcLen : Length of Cipher data to be decrypted (multiple by chunk size, SIZE_SECUREOBJECT) + * @param [out] Dst : Encrypted data + * @param [out] *DstLen : a pointer to length of encrypted data (multiple by secure object size, SIZE_CHUNK) + * + * return TZCRYPT_SUCCESS if operation has been succesfully completed. (Refer to the tlc error code) + */ +TZCRYPT_Result TzCrypt_Decrypt(TZCRYPT_UINT8 *Src, TZCRYPT_UINT32 SrcLen, TZCRYPT_UINT8 *Dst, TZCRYPT_UINT32 *DstLen); + +/* + * This function provides an hash of user data. + * + * @param [in] Src : Plain information + * @param [in] SrcLen : Length of Plain information + * @param [out] Dst : Hashed information + * @param [out] *DstLen : a pointer to length of hashed information + + * return TZCRYPT_SUCCESS if operation has been succesfully completed. (Refer to the tlc error code) + */ +TZCRYPT_Result TzCrypt_Hash(TZCRYPT_UINT8 *Src, TZCRYPT_UINT32 SrcLen, TZCRYPT_UINT8 *Dst, TZCRYPT_UINT32 *DstLen); + +/* + * This function provides an wrapping of App data. (+ include hash operation) + * + * @param [in] Src : Plain information + * @param [in] SrcLen : Length of Plain information + * @param [out] Dst : Wrapped information + * @param [out] *DstLen : a pointer to length of wrapped information + + * return TZCRYPT_SUCCESS if operation has been succesfully completed. (Refer to the tlc error code) + */ +TZCRYPT_Result TzCrypt_WrapIdentity(TZCRYPT_UINT8 *Src, TZCRYPT_UINT32 SrcLen, TZCRYPT_UINT8 *Dst, TZCRYPT_UINT32 *DstLen); + +/* + * This function provides an unwrapping of App data. (- exclude hash operation) + * + * @param [in] Src : Plain information + * @param [in] SrcLen : Length of Plain information + * @param [out] Dst : Wrapped information + * @param [out] *DstLen : a pointer to length of wrapped information + + * return TZCRYPT_SUCCESS if operation has been succesfully completed. (Refer to the tlc error code) + */ +TZCRYPT_Result TzCrypt_UnwrapIdentity(TZCRYPT_UINT8 *Src, TZCRYPT_UINT32 SrcLen, TZCRYPT_UINT8 *Dst, TZCRYPT_UINT32 *DstLen); + +/* + * This function provides the length of secure object from a given length of source data + * + * @param [in] SrcLen : Length of Plain information + * + * return TZCRYPT_UINT32 (size) if operation has been succesfully completed. + */ +TZCRYPT_UINT32 TzCrypt_GetSOLen(TZCRYPT_UINT32 SrcLen); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/tltzcrypt_api.h b/include/tltzcrypt_api.h new file mode 100755 index 0000000..6a56d97 --- /dev/null +++ b/include/tltzcrypt_api.h @@ -0,0 +1,84 @@ +/* + * + */ +#ifndef TLTZCRYPT_API_H_ +#define TLTZCRYPT_API_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "tci.h" + +/* Command ID's for communication Trustlet Connector -> Trustlet. */ +#define CMD_ENCRYPT_TZ_CRYPT 0x00000001 +#define CMD_DECRYPT_TZ_CRYPT 0x00000002 +#define CMD_WRAPIDENTITY_TZ_CRYPT 0x00000003 +#define CMD_UNWRAPIDENTITY_TZ_CRYPT 0x00000004 +#define CMD_HASH_TZ_CRYPT 0x00000005 + +/* Return codes */ +#define RET_TL_OK 0x00000000 + +/* Error codes */ +#define RET_ERR_ENCRYPT_TZ_CRYPT 0x10000001 +#define RET_ERR_DECRYPT_TZ_CRYPT 0x10000002 +#define RET_ERR_WRAPIDENTITY_TZ_CRYPT 0x10000003 +#define RET_ERR_UNWRAPIDENTITY_TZ_CRYPT 0x10000004 +#define RET_ERR_HASH_TZ_CRYPT 0x10000005 + +/* Termination codes */ +#define EXIT_ERROR ((uint32_t)(-1)) + +#define SIZE_CHUNK 1024 +#define SIZE_SECUREOBJECT 1116 // SO SIZE for 1024 byte (predefined) +#define SIZE_HASHAPPIDENTITY 32 +#define SIZE_WRAPAPPIDENTITY 124 + +/* TCI message data. */ +typedef struct { + uint32_t id; + //uint32_t data_len; + //uint8_t *data_ptr; + //uint8_t data[MAX_DATA_LEN]; +} tci_cmd_t; + +typedef struct { + uint32_t id; + uint32_t return_code; + //uint32_t data_len; + //uint8_t *data_ptr; + //uint8_t data[MAX_DATA_LEN]; +} tci_resp_t; + + +typedef union { + uint8_t input_data[SIZE_CHUNK]; + uint8_t output_data[SIZE_SECUREOBJECT]; +} buffer_t; + +typedef union { + uint8_t hash_identity[SIZE_HASHAPPIDENTITY]; + uint8_t wrap_identity[SIZE_WRAPAPPIDENTITY]; +} identity_t; + +typedef struct { + union { + tci_cmd_t cmd; /* Command message structure */ + tci_resp_t resp; /* Response message structure */ + }; + uint32_t pData; + uint32_t pLen; + uint32_t cData; + uint32_t cLen; +} tciMessage_t; + +/* Trustlet UUID. */ +#define TL_TZ_CRYPT_UUID { { 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7 } } + +#ifdef __cplusplus +} +#endif + +#endif /* TLTZCRYPT_API_H_ */ diff --git a/libs/libShpSec.a b/libs/libDeviceInfo.a old mode 100644 new mode 100755 similarity index 78% rename from libs/libShpSec.a rename to libs/libDeviceInfo.a index 6b34c6fe0ed939869d32efee1c8a5169b8348f2f..431359fbbcb842ddcebac3941d4fe2364dbfddb3 GIT binary patch delta 6248 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 diff --git a/libs/libtzcrypt.a b/libs/libtzcrypt.a new file mode 100755 index 0000000000000000000000000000000000000000..d052e49e185e0aa43ddc90c2288504901a618959 GIT binary patch literal 14410 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 Jh^Dgqe*x~}4MYF{ literal 0 HcmV?d00001 diff --git a/packaging/libcryptsvc.spec b/packaging/libcryptsvc.spec old mode 100644 new mode 100755 index 17c51a6..fbe1a55 --- a/packaging/libcryptsvc.spec +++ b/packaging/libcryptsvc.spec @@ -1,7 +1,7 @@ Name: libcryptsvc Summary: nothing Version: 0.0.1 -Release: 3 +Release: 4 Group: Osp/Security License: APLv2 Source0: %{name}-%{version}.tar.gz diff --git a/srcs/SecCryptoSvc.c b/srcs/SecCryptoSvc.c old mode 100644 new mode 100755 index 418208e..9ce42a3 --- a/srcs/SecCryptoSvc.c +++ b/srcs/SecCryptoSvc.c @@ -1,89 +1,90 @@ -/* - * libcryptsvc - device unique key - * - * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -#include "SecCryptoSvc.h" -//#include "SecKmBase64.h" -//#include "CryptoSvc-debug.h" -#include -#include -#include -#include -#include -#include -#include - -bool SecFrameGeneratePlatformUniqueKey(IN UINT32 uLen, IN OUT UINT8 *pCek) -{ - bool bResult = true; - unsigned int i = 0; - unsigned char Key[73] = {0}; - unsigned char hashedValue[HASH_LEN] = {0}; - int nTempLen = SEC_DUK_SIZE; - int nHashLen = 0; - int remain = 0; - unsigned char *result = NULL; - - SLOGD("[LOG][%s:L%d] Enter \n", __func__,__LINE__); -#ifdef CRYPTOSVC_TARGET - SysSecBootGetDeviceUniqueKey(Key); -#else - memset(Key, 0xFF, nTempLen); -#endif - - /* for debugging */ - SLOGD("Device Unique Key Information \n"); - - memcpy(Key+nTempLen, SEC_FRAME_OSP_KEY, 9); - nTempLen += 9; - - remain = uLen; - - for( i = 0 ; i < uLen ; i += HASH_LEN ) - { - result = SHA1(Key, nTempLen, hashedValue); - nHashLen = HASH_LEN; - - if( result == NULL) - { - SLOGE("SecCryptoHash fail \n"); - bResult = false; - goto ERR; - } - - nTempLen = nHashLen; - - if( remain < HASH_LEN ) - { - memcpy(pCek+i, hashedValue, remain); - } - else - { - memcpy(pCek+i, hashedValue, nHashLen); - } - - remain -= HASH_LEN; - memset(Key, 0, sizeof(Key)); - memcpy(Key, hashedValue, nHashLen); - } - SLOGD("[LOG][%s:L%d] End \n", __func__,__LINE__); -ERR: - SLOGD("[LOG][%s:L%d] End with ERROR \n", __func__,__LINE__); - return bResult; -} - +/* + * libcryptsvc - device unique key + * + * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include "SecCryptoSvc.h" +//#include "SecKmBase64.h" +//#include "CryptoSvc-debug.h" +#include +#include +#include +#include +#include +#include +#include + +bool SecFrameGeneratePlatformUniqueKey(IN UINT32 uLen, IN OUT UINT8 *pCek) +{ + bool bResult = true; + unsigned int i = 0; + unsigned char Key[73] = {0}; + unsigned char hashedValue[HASH_LEN] = {0}; + int nTempLen = SEC_DUK_SIZE; + int nHashLen = 0; + int remain = 0; + unsigned char *result = NULL; + + SLOGD("[LOG][%s:L%d] Enter \n", __func__,__LINE__); +#ifdef CRYPTOSVC_TARGET + SysSecBootGetDeviceUniqueKey(Key); +#else + memset(Key, 0xFF, nTempLen); +#endif + + /* for debugging */ + SLOGD("Device Unique Key Information \n"); + + memcpy(Key+nTempLen, SEC_FRAME_OSP_KEY, 9); + nTempLen += 9; + + remain = uLen; + + for( i = 0 ; i < uLen ; i += HASH_LEN ) + { + result = SHA1(Key, nTempLen, hashedValue); + nHashLen = HASH_LEN; + + if( result == NULL) + { + SLOGE("SecCryptoHash fail \n"); + bResult = false; + goto ERR; + } + + nTempLen = nHashLen; + + if( remain < HASH_LEN ) + { + memcpy(pCek+i, hashedValue, remain); + } + else + { + memcpy(pCek+i, hashedValue, nHashLen); + } + + remain -= HASH_LEN; + memset(Key, 0, sizeof(Key)); + memcpy(Key, hashedValue, nHashLen); + } + SLOGD("[LOG][%s:L%d] End \n", __func__,__LINE__); +ERR: + SLOGD("[LOG][%s:L%d] End with ERROR \n", __func__,__LINE__); + return bResult; +} + + diff --git a/srcs/SecTzSvc.c b/srcs/SecTzSvc.c new file mode 100755 index 0000000..86f553e --- /dev/null +++ b/srcs/SecTzSvc.c @@ -0,0 +1,204 @@ +/* + * libTzSvc - encryption and decryption with the TZ-based HW key + * + * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "SecTzSvc.h" +#include "SecCryptoSvc.h" +#include "tlc_tzcrypt.h" +#include "tltzcrypt_api.h" + +#define LOG_TAG "tlcTzCrypt" +#ifndef CRYPTOSVC_TZ +#define SIZE_CHUNK 1024 +#define SIZE_SECUREOBJECT 1116 +#define KEY_SIZE 16 +#endif + +unsigned char* AES_Crypto(unsigned char* p_text, unsigned char* c_text, unsigned char* aes_key, unsigned char* iv, int mode, unsigned long size) +{ + AES_KEY e_key, d_key; + + AES_set_encrypt_key(aes_key, 128, &e_key); + AES_set_decrypt_key(aes_key, 128, &d_key); + + if(mode == 1) + { + AES_cbc_encrypt(p_text, c_text, size, &e_key, iv, AES_ENCRYPT); + return c_text; + } + else + { + AES_cbc_encrypt(c_text, p_text, size, &d_key, iv, AES_DECRYPT); + return p_text; + } +} +TZCRYPT_Result SecEncryptTZCrypt(TZCRYPT_UINT8 *Src, TZCRYPT_UINT32 SrcLen, TZCRYPT_UINT8 *Dst, TZCRYPT_UINT32 *DstLen, TZCRYPT_UINT8 *AppInfo, TZCRYPT_UINT32 AppInfoLen, TZCRYPT_UINT8 *WrapAppInfo, TZCRYPT_UINT32 *WrapAppInfoLen) +{ + + TZCRYPT_Result ret = SEC_CRYPTO_ENCRYPT_ERROR; +#ifndef CRYPTOSVC_TZ + int outLen = 0; + unsigned char key[KEY_SIZE] = {0,}; + unsigned char hashOut[SHA_DIGEST_LENGTH] = {0,}; + unsigned char iv[] = {0x3E, 0xB5, 0x01, 0x45, 0xE4, 0xF8, 0x75, 0x3F, 0x08, 0x9D, 0x9F, 0x57, 0x3B, 0x63, 0xEF, 0x4B }; +#endif + +#ifdef CRYPTOSVC_TZ + if(SrcLen % SIZE_CHUNK != 0 || *DstLen % SIZE_SECUREOBJECT != 0){ + LOGE("Plain chunk size :: Test for Encryption of TZ Crypt failed!!! [Return Value] = %.8x\n", ret); + LOGE("source length = %d, destination length = %d\n", SrcLen, *DstLen); + return ret; + } +#endif + + LOGI("Start Encryption of TZ Crypt!\n"); + +#ifdef CRYPTOSVC_TZ + ret = TzCrypt_WrapIdentity(AppInfo, AppInfoLen, WrapAppInfo, WrapAppInfoLen); + if (ret) { + LOGE("Failed to wrap AppInfo of TZ [Return Value] = %.8x\n", ret); + return SEC_CRYPTO_WRAPIDENTITY_ERROR; + } + ret = TzCrypt_Encrypt(Src, SrcLen, Dst, DstLen); + if (ret) { + LOGE("Test for Encryption of TZ Crypt failed!!! [Return Value] = %.8x\n", ret); + return SEC_CRYPTO_ENCRYPT_ERROR; + } +#else + if(!SecFrameGeneratePlatformUniqueKey(KEY_SIZE, key)) + { + LOGE("Failed to generate device unique key\n"); + return SEC_CRYPTO_ENCRYPT_ERROR; + } + if(AES_Crypto(Src, Dst, key, iv, 1, SrcLen) == NULL) + { + LOGE("Failed to encrypt data \n"); + return SEC_CRYPTO_ENCRYPT_ERROR; + } + *DstLen = SrcLen; + EVP_Digest(AppInfo, AppInfoLen, hashOut, (unsigned int*)&outLen, EVP_sha1(), NULL); + *WrapAppInfoLen = outLen; + memcpy(WrapAppInfo, hashOut, *WrapAppInfoLen); +#endif + LOGI("Encryption of TZ Crypt is Success! [Return Value] = %.8x\n", ret); + + return SEC_CRYPTO_SUCCESS; +} + +TZCRYPT_Result SecDecryptTZCrypt(TZCRYPT_UINT8 *Src, TZCRYPT_UINT32 SrcLen, TZCRYPT_UINT8 *Dst, TZCRYPT_UINT32 *DstLen, TZCRYPT_UINT8 *AppInfo, TZCRYPT_UINT32 AppInfoLen, TZCRYPT_UINT8 *WrapAppInfo, TZCRYPT_UINT32 WrapAppInfoLen) +{ + TZCRYPT_Result ret = SEC_CRYPTO_DECRYPT_ERROR; +#ifndef CRYPTOSVC_TZ + int outLen = 0; + unsigned char key[KEY_SIZE] = {0,}; + unsigned char hashOut[SHA_DIGEST_LENGTH] = {0,}; + unsigned char iv[] = {0x3E, 0xB5, 0x01, 0x45, 0xE4, 0xF8, 0x75, 0x3F, 0x08, 0x9D, 0x9F, 0x57, 0x3B, 0x63, 0xEF, 0x4B }; +#endif +#ifdef CRYPTOSVC_TZ + if(SrcLen % SIZE_SECUREOBJECT != 0 ){ + LOGE("Ciphertext chunk size :: Test for Encryption of TZ Crypt failed!!! [Return Value] = %.8x\n", ret); + return ret; + } + + if(WrapAppInfoLen != SIZE_WRAPAPPIDENTITY){ + LOGE("Wrapped App Identity Size :: failed!!! [Return Value] = %.8x\n", ret); + return ret; + } + + TZCRYPT_UINT8 *unwrapData = NULL; + TZCRYPT_UINT32 unwrapDatalen = SIZE_HASHAPPIDENTITY; + unwrapData = (TZCRYPT_UINT8 *)malloc(unwrapDatalen); + + ret = TzCrypt_UnwrapIdentity(WrapAppInfo, WrapAppInfoLen, unwrapData, &unwrapDatalen); + if (ret) { + LOGE("Test for Unwrap AppInfo of TZ Crypt failed!!! [Return Value] = %.8x\n", ret); + return SEC_CRYPTO_UNWRAPIDENTITY_ERROR; + } + LOGI("Unwrap AppInfo of TZ Crypt is Success! [Return Value] = %.8x\n", ret); + + TZCRYPT_UINT8 *hashData = NULL; + TZCRYPT_UINT32 hashDatalen = SIZE_HASHAPPIDENTITY; + hashData = (TZCRYPT_UINT8 *)malloc(hashDatalen); + + ret = TzCrypt_Hash(AppInfo, AppInfoLen, hashData, &hashDatalen); + if (ret) { + LOGE("Test for Hash AppInfo of TZ Crypt failed!!! [Return Value] = %.8x\n", ret); + return SEC_CRYPTO_HASH_ERROR; + } + + if( 0 != memcmp(unwrapData, hashData, hashDatalen) || hashDatalen != unwrapDatalen){ + LOGE("App Info Identity is NOT same as hash Info of a given Identity\n"); + return SEC_CRYPTO_HASH_ERROR; + } + + LOGI("Start Decryption of TZ Crypt!\n"); + ret = TzCrypt_Decrypt(Src, SrcLen, Dst, DstLen); + if (ret) { + LOGE("Test for Decryption of TZ Crypt failed!!! [Return Value] = %.8x\n", ret); + return SEC_CRYPTO_DECRYPT_ERROR; + } +#else + if(!SecFrameGeneratePlatformUniqueKey(KEY_SIZE, key)) + { + LOGE("Failed to generate device unique key\n"); + return SEC_CRYPTO_DECRYPT_ERROR; + } + + EVP_Digest(AppInfo, AppInfoLen, hashOut, (unsigned int*)&outLen, EVP_sha1(), NULL); + + if( 0 != memcmp(WrapAppInfo, hashOut, outLen) || outLen != WrapAppInfoLen){ + LOGE("AppInfo Identifier Information is wrong\n"); + return SEC_CRYPTO_HASH_ERROR; + } + + if(AES_Crypto(Dst, Src, key, iv, 0, SrcLen) == NULL) + { + LOGE("Failed to decrypt data \n"); + return SEC_CRYPTO_DECRYPT_ERROR; + } + *DstLen = SrcLen; + +#endif + LOGI("Test for Decryption of TZ Crypt is Success! [Return Value] = %.8x\n", ret); + + return SEC_CRYPTO_SUCCESS; +} + +TZCRYPT_UINT32 SecGetCipherLen(TZCRYPT_UINT32 srclen) +{ +#ifdef CRYPTOSVC_TZ + TZCRYPT_UINT32 cipherLength = TzCrypt_GetSOLen(srclen); +#else + int cipherLength = (srclen / EVP_aes_128_cbc()->block_size + 1) * EVP_aes_128_cbc()->block_size; +#endif + return cipherLength; +} -- 2.7.4