本文转载自:https://blog.csdn.net/hovan/article/details/42520879html
从trust zone之我见知道,支持trustzone的芯片会跑在两个世界。编程
普通世界、安全世界,对应高通这边是HLOS,QSEE。api
以下图:安全
以下是HLOS与QSEE的软件架构图架构
HLOS这两分为kernel层,user层。user层的经过qseecom提供的API起动trustzone那边的app。app
qseecom driver 除了提供API,还调用scm函数作世界切换。函数
scm driver 那边接到qseecom的调用后,会把HLOS相关数据(包括指令参数)放入指它buffer,而后执行scm调用。ui
qsapp经过qsee提供的api接受来自HLOS那边的请求,并把执行结果返回HLOS。加密
qsee除了提供API,还与从monitor把来自HLOS的数据传给qsapp,而后把qsapp的数据返回给HLOS。.net
monitor就不用说了,切换世界用的,还处理shared buffer的内容。
是大概的架构图,细节比较复杂,没有开元。
下面经过一个简单的qseecom_security_test代码来讲明整个调用流程。
以下图:
qseecom_security_test.c
int main( int argc, char *argv[] )
{
....
/* Initialize the global/statics to zero */
memset( g_qseeCommHandles, 0, sizeof(g_qseeCommHandles) );
memset( g_xors, 0, sizeof(g_xors) );
先初始化全局变量g_qseeCommHandles
for( j = 0; j < NUM_CLIENTS; j++ ) {
/* Initialize the barriers to ensure that commands aren't sent before the listeners
* have been started. Otherwise, errors will be generated.
*/
ret = sem_init( &barrier[j], 0, 0 );//初始化一个信号量
if( ret ) {
LOGD( "barrier init failed %i, %i", ret, errno );
g_err = -1;
break;
}
ret = pthread_create( &threads[j], NULL, &test_thread, (void*)j );//建立test_thread线程
}
初始化一个barrier信号变量,用于线程建立时的同步
而后调用pthread_create()函数建立test_thread线程,该线程将会起动QSApp。
void *test_thread( void* threadid )
{
...
do {
.....
LOGD( "T%#X: Starting QSApp...", (uint32_t)threadid );
ret = QSEECom_start_app( &g_qseeCommHandles[tid][0], "/firmware/image",//起动名为securitytest的QSApp
"securitytest", sizeof(qseecom_req_res_t)*2 );
LOGD( "T%#X: Started QSApp...", (uint32_t)threadid );
CHECK_RETURN( ret, __LINE__ );
跟着来到test_thread线程
调用QSEECom_start_app()函数起动QSApp。
这个函数在kernel实现 以下:
qseecom.c
static int qseecom_load_app(struct qseecom_dev_handle *data, void __user *argp)
{
...
/* Get the handle of the shared fd */
ihandle = ion_import_dma_buf(qseecom.ion_clnt,
load_img_req.ifd_data_fd);
...
/* SCM_CALL to load the app and get the app_id back */
ret = scm_call(SCM_SVC_TZSCHEDULER, 1, &load_req,
sizeof(struct qseecom_load_app_ireq),
&resp, sizeof(resp));
Get shared buf fd,用于与安全世界通讯
调用scm_call()来陷入安全世界。
scm_call()实现以下:
arch/arm/mach-msm/scm.c
int scm_call(u32 svc_id, u32 cmd_id, const void *cmd_buf, size_t cmd_len,
void *resp_buf, size_t resp_len)
{
...
ret = scm_call_common(svc_id, cmd_id, cmd_buf, cmd_len, resp_buf,
resp_len, cmd, len);
kfree(cmd);
return ret;
}
scm_call_common的实现以下:
static int scm_call_common(u32 svc_id, u32 cmd_id, const void *cmd_buf,
size_t cmd_len, void *resp_buf, size_t resp_len,
struct scm_command *scm_buf,
size_t scm_buf_length)
{
....
mutex_lock(&scm_lock);
ret = __scm_call(scm_buf);//调用
mutex_unlock(&scm_lock);
if (ret)
return ret;
rsp = scm_command_to_response(scm_buf);
start = (unsigned long)rsp;
do {
scm_inv_range(start, start + sizeof(*rsp));
} while (!rsp->is_complete);
end = (unsigned long)scm_get_response_buffer(rsp) + resp_len;
scm_inv_range(start, end);
if (resp_buf)
memcpy(resp_buf, scm_get_response_buffer(rsp), resp_len);
return ret;
}
调用__scm_call()陷入安全世界,回来后调用scm_get_response_buffer()获取安全世界返回的信息供上面QSApp client用
__scm_call实现以下:
static int __scm_call(const struct scm_command *cmd)
{
...
ret = smc(cmd_addr);
...
return ret;
}
smc实现以下:
static u32 smc(u32 cmd_addr)
{
int context_id;
register u32 r0 asm("r0") = 1;
register u32 r1 asm("r1") = (u32)&context_id;
register u32 r2 asm("r2") = cmd_addr;
do {
asm volatile(
__asmeq("%0", "r0")
__asmeq("%1", "r0")
__asmeq("%2", "r1")
__asmeq("%3", "r2")
#ifdef REQUIRES_SEC
".arch_extension sec\n"
#endif
"smc #0 @ switch to secure world\n"
: "=r" (r0)
: "r" (r0), "r" (r1), "r" (r2)
: "r3");
} while (r0 == SCM_INTERRUPTED);
return r0;
}
是一段汇编程序,好吧,安全世界的QSApp已经运行起来了,当QSApp完成相应服务后就会返回数据。这个函数就会返回。
Starting QSApp已经完成,下面就注册listener,这个listener用于监听QSApp那边的请求。由于有时QSApp也须要HLOS这边作一些事。
实现以下:
void *listener_thread( void* threadid )
{
....
do {
...
/* Register as a listener with the QSApp */
LOGD( "L%#X: Registering as listener with QSApp...", (uint32_t)threadid );
ret = QSEECom_register_listener( &g_qseeCommHandles[parent_tid][tid], GET_LSTNR_SVC_ID(parent_tid, tid),
sizeof(qseecom_req_res_t), 0 );
....
for( ;; ) {
/* Wait for request from the QSApp */
ret = QSEECom_receive_req( g_qseeCommHandles[parent_tid][tid], req_res, sizeof(qseecom_req_res_t) );
if( ret ) break;
....
/* Send the response to the QSApp */
ret = QSEECom_send_resp( g_qseeCommHandles[parent_tid][tid], req_res, sizeof(qseecom_req_res_t) );
CHECK_RETURN( ret, __LINE__ );
}
} while( 0 );
...
}
这个函数比较长,简化一下,分步来看
首先调用QSEECom_register_listener()函数来注册监听,告诉QSApp,我能够接收你的申请。
再次看到for循环没有,这就是一直等待QSApp那边的消息,一但有消息QSEECom_reveive_req就返回,这边处理完以后。
再调用qSEECom_send_resp()发送response给QSApp。
不管是起动QSApp,仍是注册listener都是线程中执行,一但全部线程都退出后就会调用QSEECom_shutdown_app()函数中止QSApp。
整个过程执行完毕。以下:
void *test_thread( void* threadid )
{
...
if ( g_qseeCommHandles[tid][0] != NULL ) {
QSEECom_shutdown_app( &g_qseeCommHandles[tid][0] );
}
} while( 0 );
pthread_exit( NULL );
return NULL;
}
注:QSEECom _XX开头的函数都在kernel中的qseecom.c里实现,scm系统调用,都在scm.c中实现。
HLOS user层把握QSEEComAPI.h文件
HLOS kernel层把握qseecom.c 和 scm.c两文件
谢谢
--------------------- 本文来自 hovan-邓永坚 的CSDN 博客 ,全文地址请点击:https://blog.csdn.net/hovan/article/details/42674055?utm_source=copy
从硬件背景上看TZ是在ARMv6的架构上产生的,在ARMv7上从新设计了,TZ的目的是提供一个软硬件都安全的环境,安全的环境是单独的运行在一个硬件空间,和非安全的进行了硬件上的隔离。
QSEE主要负责加载APP,以及安全APP的堆栈管理,提供安全的API接口,安全的字符操做和LOG功能
QSAPPS是高通开发的APP,运行在QSEE之上
用户空间经过加载并调用QSEEAPP来是实现一些安全数据或敏感操做的加密
QSEEComAPIlib是暴露给HLOS的API,HLOS客户端和监听端利用QSEEComdriver经过这些API来和QSEE进行数据的收和发。
QSEEComclient是须要调用QSEECom_start_app来获得一个句柄指向QSEECom字符设备,而且能够用这个句柄来进行数据的首发
QSEEComlistener须要用QSEECom_register_listener来注册,能够注册多个listener,每一个listener所在的线程将会被挂起,直到接收到包含到该listener的信息。
QSEEComdriver是一个字符型设备,经过IOCTL来和QSEECom进行通信,这些IOCTL都应该被QSEEComAPI进行调用
由于qsee不开源 tz部分只能看到少许符号
因此主要从用户和开发角度观察tz
开发须要开发相应的qsapp来实现安全的一些数据操做
用户态中须要加载相应的qsapp,而且利用qsapplib提供的API来和qsapp进行通信
而qsapp如何与qsee进行通信的呢
qsapp则调用scm来将数据保存到安全空间
为何tz能实现安全呢
从硬件上 就区分了两个世界,安全世界用一根总线,非安全世界用一根总线
非安全世界的操做没法访问到安全世界
必须经过qsee中的scm调用来访问
而用户操做只能访问qsapp
因此达到了安全保护的做用