开发一个TEE简单存储模块

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

// 所有TEE操作，都会返回这个类型的值，代表执行结果
typedef uint32_t TEEC_Result;

// 各种错误码，作为TEEC_Result类型的函数返回值使用
// 下面这些是最常用到的
#define TEEC_SUCCESS                       0x00000000
#define TEEC_ERROR_GENERIC                 0xFFFF0000
#define TEEC_ERROR_ITEM_NOT_FOUND          0xFFFF0008
#define TEEC_ERROR_SHORT_BUFFER            0xFFFF0010

// 代表客户端和TEE之间的一个连接，具体实现由芯片平台关注，
// 用户只需要使用TEEC_InitializeContext和TEEC_FinalizeContext即可
typedef struct {
        /* Implementation defined */
        int fd; 
        bool reg_mem;
        bool memref_null;
} TEEC_Context;

// 代表一个CA和TA之间的连接，也是由芯片平台实现，
// 用户只需要使用TEEC_OpenSession和TEEC_CloseSession即可
typedef struct {
        /* Implementation defined */
        TEEC_Context *ctx; 
        uint32_t session_id;
} TEEC_Session;

// 携带执行TEEC_InvokeCommand时需要的参数类型，以及每个参数
typedef struct {
        uint32_t started;
        uint32_t paramTypes;
        // TEEC_CONFIG_PAYLOAD_REF_COUNT的值是4，表示最大支持4个参数
        TEEC_Parameter params[TEEC_CONFIG_PAYLOAD_REF_COUNT];
        /* Implementation-Defined */
        TEEC_Session *session; 
} TEEC_Operation;

// TEEC_Parameter是一个union，这样就能很方便地将这块儿内存作为三种用途地任意一种来使用；
typedef union {
        TEEC_TempMemoryReference tmpref;
        TEEC_RegisteredMemoryReference memref;
        TEEC_Value value;
} TEEC_Parameter;

// TEEC_Value是最简单参数类型，注意这里其实可以携带两个int
typedef struct {
        uint32_t a;
        uint32_t b;
} TEEC_Value;

// TEEC_TempMemoryReference 是最简单地一种ref类型
typedef struct {
        void *buffer;
        size_t size;
} TEEC_TempMemoryReference;

// 我的理解是，TEEC_RegisteredMemoryReference中Registered的意思是，
// 向其parent“注册”并使用parent内从offset开始，长度为size的一块儿内存，
// 也就是说同一个TEEC_SharedMemory *parent可以“注册”（其实就是分割）出来很多个 TEEC_RegisteredMemoryReference
// 当然，管理多块儿内存就是程序员自己的责任了，最基本的是避免内存块儿的offset交错导致的内存互相踩踏
typedef struct {
        TEEC_SharedMemory *parent;
        size_t size;
        size_t offset;
} TEEC_RegisteredMemoryReference;

// 上述TEEC_SharedMemory需要通过TEEC_AllocateSharedMemory来分配，
// 通常我们只关心其buffer、size、flags即可，其他的属性都是由实现者（通常是芯片供应商）实现；
// 看到这里我们可以确认，要想使用 TEEC_RegisteredMemoryReference 类型，需要先分配一个 TEEC_SharedMemory 出来，
// 然后将TEEC_RegisteredMemoryReference类型的parent指针指向刚刚获得的TEEC_SharedMemory，
// 这个过程在后面函数 read_secure_object 里由很清楚的体现
typedef struct {
        void *buffer;    //实际存储区域
        size_t size;	 //buffer的大小
        uint32_t flags;  //数据传输方向，TEEC_MEM_INPUT和TEEC_MEM_OUTPUT二者之一或者合并
        // Implementation-Defined
        int id;
        size_t alloced_size;
        void *shadow_buffer;
        int registered_fd;
        union {
                bool dummy;
                uint8_t flags;
        } internal;
} TEEC_SharedMemory;

// 上面TEEC_Operation的 paramTypes 的类型是下面一系列宏定义
// 对应序号的参数不使用
#define TEEC_NONE                   0x00000000
// TEEC_VALUE_开头的表示传递一个值，input/output/inout表征方向
#define TEEC_VALUE_INPUT            0x00000001
#define TEEC_VALUE_OUTPUT           0x00000002
#define TEEC_VALUE_INOUT            0x00000003

// TEEC_MEMREF_开头的表示传递一个内存引用，通常用于携带非数值类信息，具体分为下面三类：

// Temp相关的表示类型是 TEEC_TempMemoryReference
#define TEEC_MEMREF_TEMP_INPUT      0x00000005
#define TEEC_MEMREF_TEMP_OUTPUT     0x00000006
#define TEEC_MEMREF_TEMP_INOUT      0x00000007

// TEEC_MEMREF_WHOLE表示已read only方式将parent内存块作为一个整体使用，
// 类型是TEEC_MemoryReference，一般很少用这种类型
#define TEEC_MEMREF_WHOLE           0x0000000C

// TEEC_MEMREF_PARTIAL_开头的表示类型是 TEEC_RegisteredMemoryReference
#define TEEC_MEMREF_PARTIAL_INPUT   0x0000000D
#define TEEC_MEMREF_PARTIAL_OUTPUT  0x0000000E
#define TEEC_MEMREF_PARTIAL_INOUT   0x0000000F

// 下面两个标记数据传输的方向，当需要双向传输（例如读文件时），可以并起来使用
// 通常用于分配好TEEC_SharedMemory空间后，初始化TEEC_SharedMemory的flags属性
#define TEEC_MEM_INPUT   0x00000001
#define TEEC_MEM_OUTPUT  0x00000002

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 这是调用TA_InvokeCommandEntryPoint时传输的参数，对比CA的参数类型可以发现，TA端将所有的内存类型统一为一种memref
// 同样是union类型，TEE_Param可以动态的根据入参类型正确获取参数；
typedef union {
    struct {
            void *buffer;
            uint32_t size;
    } memref;
    struct {
            uint32_t a;
            uint32_t b;
    } value;
} TEE_Param;

// 代表TEE内的一个文件对象，代码注释里面写得很清楚，它是opaque的
typedef struct __TEE_ObjectHandle *TEE_ObjectHandle;

// 代表一个TEE对象的信息，我们比较关心的是其中的dataSize的值，即对应文件的大小
// TEE_ObjectInfo是通过下面函数获取的（函数名字中确实带有一个数字1）：
// TEE_Result TEE_GetObjectInfo1(TEE_ObjectHandle object, TEE_ObjectInfo *objectInfo);
typedef struct {
        uint32_t objectType;
        __extension__ union {
                uint32_t keySize;       /* used in 1.1 spec */
                uint32_t objectSize;    /* used in 1.1.1 spec */
        };
        __extension__ union {
                uint32_t maxKeySize;    /* used in 1.1 spec */
                uint32_t maxObjectSize; /* used in 1.1.1 spec */
        };
        uint32_t objectUsage;
        uint32_t dataSize;
        uint32_t dataPosition;
        uint32_t handleFlags;
} TEE_ObjectInfo;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// ~~~~~~~~ 内存管理相关的函数（TA的内存管理，必须使用TEE提供的函数）：
// 申请内存
void *TEE_Malloc(uint32_t size, uint32_t hint);
// 释放内存
void TEE_Free(void *buffer);
// 内存填充
void *TEE_MemFill(void *buff, uint32_t x, uint32_t size);
// 名字具有迷惑性，实际上这是一个内存拷贝函数
void *TEE_MemMove(void *dest, const void *src, uint32_t size);
// 检查当前TA是否有权限访问指定的内存，
// 在读文件时，获取的内存buffer来自于CA，所以实际执行TEE_MemMove之前必须检查一下，
// 如果buffer本身是TA自己刚刚通过TEE_Malloc获取的，一般是不需要检查的；
TEE_Result TEE_CheckMemoryAccessRights(uint32_t accessFlags, void *buffer, uint32_t size);

// ~~~~~~~~ 常用文件对象的函数：
// 获取文件对象的信息，我们最关心的是文件大小，一般用于比较文件大小和来自CA的buffer的大小；
TEE_Result TEE_GetObjectInfo1(TEE_ObjectHandle object, TEE_ObjectInfo *objectInfo);
// 关闭一个文件对象，可以是持久的（已经写入TEE的），也可以是非持久的（还没有写入TEE的）；
void TEE_CloseObject(TEE_ObjectHandle object);

// ~~~~~~~~ 持久化对象相关的函数：
// 打开一个“已经存在的”TEE文件对象的handle，所以涉及到读和删的时候，必须先用这个函数打开文件
TEE_Result TEE_OpenPersistentObject(uint32_t storageID, const void *objectID,
                            uint32_t objectIDLen, uint32_t flags, TEE_ObjectHandle *object);

// 基于指定好的属性，创建一个TEE内的文件对象，所以往TEE写文件时，必然会用到这个函数
TEE_Result TEE_CreatePersistentObject(uint32_t storageID, const void *objectID,
                              uint32_t objectIDLen, uint32_t flags,
                              TEE_ObjectHandle attributes, const void *initialData,
                              uint32_t initialDataLen, TEE_ObjectHandle *object);
// 关闭并删除TEE内的文件对象，删除文件时自然必然用到；
// 另一个需要用到的场景是，创建文件，但是创建成功后写文件数据内容时出错，此时也需要将刚刚创建的文件删除掉
TEE_Result TEE_CloseAndDeletePersistentObject1(TEE_ObjectHandle object);

// ~~~~~~~~ 文件数据流访问相关的函数：
// 从object代表的对象的数据流中读取size个字节，写入指定的buffer中，实际读取的数据会被记录到count指向的内存
TEE_Result TEE_ReadObjectData(TEE_ObjectHandle object, void *buffer,
                              uint32_t size, uint32_t *count);
// 将buffer中的size个字节写入object对应的文件内
TEE_Result TEE_WriteObjectData(TEE_ObjectHandle object, const void *buffer, uint32_t size);
// 将object的文件指针reset到指定位置，
// 如果whence是TEE_DATA_SEEK_SET，则被设置到 文件开头+offset 的位置
// 如果whence是TEE_DATA_SEEK_CUR，则被设置到 当前指针+offset 的位置
// 如果whence是TEE_DATA_SEEK_END，则被设置到 文件末尾+offset 的位置
TEE_Result TEE_SeekObjectData(TEE_ObjectHandle object, int32_t offset, TEE_Whence whence);

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

int main(int argc, char *argv[]) {
    int result = 0;

    if(argc == 3) {
        // 删除
        if (strcasecmp(argv[1] , "delete") == 0) {
            int result = delete_secure_object(argv[2]);
            if(result == TEEC_SUCCESS) {
                printf("success: delete %s from TEE \n", argv[2]);
            }
            else if(result == TEEC_ERROR_ITEM_NOT_FOUND) {
                printf("ERROR:   delete %s from TEE, no such file \n", argv[2]);
            }
            else {
                printf("ERROR:   delete %s from TEE, error code = 0x%08x \n", argv[2], result);
            }
            return result;
        }
    }

    if(argc == 4) {

        // 写文本到TEE
        if(strcasecmp(argv[1] , "writetext") == 0) {
            int result = write_secure_object(argv[2], argv[3], strlen(argv[3]));
            if(result == TEEC_SUCCESS) {
                printf("success: write text '%s' into TEE as file %s \n", argv[3], argv[2]);
            }
            else {
                printf("ERROR:   write text '%s' into TEE as file %s, error = 0x%08x \n",
                       argv[3], argv[2], result);
            }
            return result;
        }
 
        // 写文件到TEE
        if(strcasecmp(argv[1] , "writefile") == 0) {
            //Step1 打开文件，获取文件长度
            FILE *input_file = fopen(argv[3], "rb");
            if (input_file == NULL) {
                printf("ERROR: Can't open file: %s \n", argv[3]);
                exit(1);
            }
            fseek(input_file, 0, SEEK_END);
            long input_file_size = ftell(input_file);
            rewind(input_file); //必须重新回到文件流开头！
            if(input_file_size == 0) {
                printf("ERROR: file empty? Are you kidding me? ^_^ \n");
                fclose(input_file);
                exit(2);
            }
            if(input_file_size > MAX_FILESIZE) {
                printf("ERROR: filesize too big, can only accept 16k or smaller file \n");
                fclose(input_file);
                exit(3);
            }
            //Step2 读取文件内容到byte数组
            char* write_buffer = malloc(input_file_size);
            if(write_buffer == NULL) {
                printf("ERROR: no memory to read file \n");
                fclose(input_file);
                exit(4);
            }
            memset(write_buffer, 0, input_file_size);
            // 注意，fread的返回值，并不是读取了多少bytes，而是读取了多少个object，
            // 这里第三个参数为1，即只读取一个大小为input_file_size的object，所以返回值1就是成功
            long read_result = fread(write_buffer, input_file_size, 1, input_file);
            if(read_result != 1) {
                printf("ERROR: read file %s, filesize=%ld, read_result =%ld \n", 
                       argv[3], input_file_size, read_result);
                fclose(input_file);
                exit(5);
            }
            else {
                fclose(input_file);
            }
            //Step3 写入TEE
            result = write_secure_object(argv[2], write_buffer, input_file_size);
            if(result == TEEC_SUCCESS) {
                printf("success: write file '%s' into TEE as file %s \n", argv[3], argv[2]);
            }
            else {
                printf("ERROR:   write file '%s' into TEE as file %s, error code = 0x%08x \n", 
                       argv[3], argv[2], result);
            }
            free(write_buffer);

            return result;
        }

        // 从TEE读取文件到Android文件系统内
        if(strcasecmp(argv[1] , "read") == 0) {
            //Step1 从TEE读取文件到缓冲区
            int buffer_size = atoi(argv[3]);
            if(buffer_size == 0) {
                printf("ERROR:   bad buffer_size \n");
                exit(6);
            }
            char* read_buffer = malloc(buffer_size);
            if(read_buffer == NULL) {
                printf("ERROR:   no memory to read TEE \n");
                exit(7);
            }
            memset(read_buffer, 0, buffer_size);
            size_t file_size = 0;
            result = read_secure_object(argv[2], read_buffer, buffer_size, &file_size);
            //Step2 读取成功则存储到文件系统
            if(result == TEEC_SUCCESS) {
                char output_path[256];
                memset(output_path, 0, 256);
                sprintf(output_path, "/sdcard/tee_%s", argv[2]);
                // wb+表示文件已经存在则清空并覆盖，如果不存在则创建
                FILE *output_file = fopen(output_path, "wb+");
                if (output_file == NULL) {
                    printf("ERROR:   Can't open file to write: %s \n", output_path);
                    exit(8);
                }
                long write_result = fwrite(read_buffer, file_size, 1, output_file);
                // 注意，同fread类似，fwrite的返回值意思是，写了多少个object，而不是写了多少个bytes
                if(write_result == 1) {
                    printf("success: read %s from TEE, and write to %s \n", 
                           argv[2], output_path);
                }
                else {
                    printf("ERROR:   read %s from TEE done, but write to %s failed \n", 
                           argv[2], output_path);
                }
                fclose(output_file);
            }
            // 常见的失败原因，给出提示
            else if(result == TEEC_ERROR_SHORT_BUFFER) {
                // 通过TA返回给CA的值，获得文件实际大小，请看上面CA和TA里读文件的注释
                printf("ERROR:   buffer too small, file size is %ld bytes \n", file_size);
            }
            else if(result == TEEC_ERROR_ITEM_NOT_FOUND) {
                printf("ERROR:   no such file in TEE: %s \n", argv[2]);
            }
            else {
                printf("ERROR:   read from TEE, error code = 0x%08x \n", result);
            }
            free(read_buffer);
            return result;
        }

    }

    // 没有走进前面的流程，则默认打印usage
    print_usage();
    return 0;
}

// 参数列表不符合预期时，打印使用方法
void print_usage() {
    printf("MyTEE cmdline \n");
    printf("Usage: \n");
    printf("mytee writetext  <tee_file_id>  <text>         \n");
    printf("mytee writefile  <tee_file_id>  <filepath>     \n");
    printf("mytee read       <tee_file_id>  <buffer_size>  \n");
    printf("mytee delete     <tee_file_id>                 \n");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

private static final int MAX_FILE_SIZE = 128 * 1024;  //TEE接受最大128k的文件，取决于各个平台TEE空间的限制
private static final int BUFFER_SIZE = 1024;
private static MyTeeClient TEE = new MyTeeClient();
private static final Object LOCK = new Object();      //读写同步锁

// Java层接口：
// 写文件，成功返回0，失败返回TEE错误码或者上层自定义错误码（自定义的不能与TEE错误码重复）
public static int write(String teeDstFileId, String text) {}
public static int write(String teeDstFileId, File reeSrcFile) {}
public static int write(String teeDstFileId, byte[] data) {}
// 删文件，复用CA层返回值，成功返回TEEC_SUCCESS，失败则为各种TEE错误码
public static int delete(String teeFileId) {}
// 读文件，成功则返回文件大小（正值），失败则返回TEE错误码（负值）
public static int read(String teeFileId, byte[] data) {}

// native函数列表，返回值均为：成功为TEEC_SUCCESS，失败则为各种TEE错误码
public native int native_write(String jFilename, byte[] jBuffer);
public native int native_read(String jFilename, byte[] jBuffer);
public native int native_delete(String jFilename);

static {
    System.loadLibrary("mytee");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

static const JNINativeMethod gMethods[] = {
//  Method-Name-in-Java;   Method-Signature;            Function-Pointer-in-C
    {"native_write",      "(Ljava/lang/String;[B)I",    (void*)tee_write_file   },
    {"native_read",       "(Ljava/lang/String;[B)I",    (void*)tee_read_file    },
    {"native_delete",     "(Ljava/lang/String;)I",      (void*)tee_delete_file  },
};

static int registerNativeMethods(JNIEnv *env, const char *className,
                                 const JNINativeMethod *methods, int numMethods) {
    int rc;
    jclass clazz;
    LOGE("~~~~~~~~~~~~~ registerNativeMethods ~~~~~~~~~~~~~~~~~~~~~");
    clazz = (*env)->FindClass(env, className);
    if (clazz == NULL) {
        LOGE("Native registration unable to find class '%s'", className);
        return -1;
    }
    if (rc = ((*env)->RegisterNatives(env, clazz, methods, numMethods)) < 0) {
        LOGE("RegisterNatives failed for '%s' %d", className, rc);
        return -1;
    }
    return 0;
}

JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;
    if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_4) != JNI_OK) {
        LOGE("GetEnv failed!");
        return -1;
    }
    if ( registerNativeMethods(env, "com/wang/tee/MyTeeClient", gMethods, NELEM(gMethods)) < 0 ) {
        LOGE("registerNativeMethods failed!");
        return -1;
    }
    return JNI_VERSION_1_4;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

// 写字符串
public static int write(String teeDstFileId, String text) {
    byte[] data = null;
    try {
        data = text.getBytes("UTF-8");
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    return write(teeDstFileId, data);
}
// 写文件
public static int write(String teeDstFileId, File reeSrcFile) {
    return write(teeDstFileId, fileToBytes(reeSrcFile));
}
// 写byte[]
public static int write(String teeDstFileId, byte[] data) {
    int result = -100;
    if(data == null ) {
        return -1;
    }
    if(data.length == 0 || data.length > MAX_FILE_SIZE) {
        return -2;
    }
    synchronized (LOCK) {
       result = TEE.native_write(teeDstFileId, data);
    }
    if (TEEC_SUCCESS == result) {
        Log.d(TAG, "writeBytes success");
    } else {
        Log.e(TAG, "writeBytes fail, result = " + result);
    }
    return result;
}
// 一个简单的工具函数
private byte[] fileToBytes(File f) {
    if (!f.exists() || !f.isFile()) {
        return null;
    }
    byte[] data = new byte[(int) f.length()];
    ByteArrayOutputStream bos = new ByteArrayOutputStream((int) f.length());
    BufferedInputStream in = null;
    try {
        in = new BufferedInputStream(new FileInputStream(f));
        byte[] buffer = new byte[BUFFER_SIZE];
        int len = 0;
        while (-1 != (len = in.read(buffer, 0, BUFFER_SIZE))) {
            bos.write(buffer, 0, len);
        }
        data = bos.toByteArray();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            in.close();
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return data;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

JNIEXPORT jint JNICALL tee_write_file(JNIEnv *env, jobject obj, 
                                      jstring jFilename, jbyteArray jBuffer) {
    TEEC_Result res;
    char * filename = (char *) (*env)->GetStringUTFChars(env, jFilename, 0);
    jbyte* buffer = (*env)->GetByteArrayElements(env, jBuffer, 0);
    if(NULL == buffer) {
        LOGE("tee_write_file: cannot get jBuffer");
        return -1;
    }
    char* buf=(char*)buffer;
    jsize  jBufferSize = (*env)->GetArrayLength(env, jBuffer);
    uint32_t bufferSize = (uint32_t)jBufferSize;

    res = write_secure_object(filename, buf, bufferSize);

    (*env)->ReleaseByteArrayElements(env, jBuffer, buffer, 0);
    (*env)->ReleaseStringUTFChars(env, jFilename, filename);
    return res;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public static int delete(String teeFileId) {
    int result = TEEC_ERROR_GENERIC;
    synchronized (LOCK) {
        result = TEE.native_delete(teeFileId);
    }
    if (TEEC_SUCCESS == result) {
        Log.d(TAG, "deleteFile success");
    } else if (TEEC_ERROR_ITEM_NOT_FOUND == result) {
        Log.e(TAG, "deleteFile fail, reason: no such file");
    } else {
        Log.e(TAG, "deleteFile fail, result = " + Integer.toHexString(result));
    }
    return result;
}

1
2
3
4
5
6
7
8

JNIEXPORT jint JNICALL tee_delete_file(JNIEnv *env, jobject obj, jstring jFilename) {
    TEEC_Result res;
    char * filename = (char *) (*env)->GetStringUTFChars(env, jFilename, 0);
    res = delete_secure_object(filename);
    LOGD("tee_delete_file will return %d", res);
    (*env)->ReleaseStringUTFChars(env, jFilename, filename);
    return res;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public static int read(String teeFileId, byte[] data) {
    int result = TEEC_ERROR_GENERIC;
    synchronized (LOCK) {
        result = TEE.native_read(teeFileId, data);
    }
    if (result > 0) {
        Log.d(TAG, "deleteFile success, file size=" + result);
    } else if (TEEC_ERROR_ITEM_NOT_FOUND == result) {
        Log.e(TAG, "deleteFile fail, reason: no such file");
    } else {
        Log.e(TAG, "deleteFile fail, result = " + Integer.toHexString(result));
    }
    return result;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

JNIEXPORT jint JNICALL tee_read_file(JNIEnv *env, jobject obj, 
                                     jstring jFilename, jbyteArray jBuffer) {
    TEEC_Result res;
    size_t file_size = 0;
    jsize buffer_size = (*env)->GetArrayLength(env, jBuffer);
    // 最后一个参数isCopy=JNI_FALSE表示不拷贝，直接使用Java堆中的内存
    jbyte *buffer = (*env)->GetByteArrayElements(env, jBuffer, JNI_FALSE);
    if (buffer == NULL) {  // 一般不会出现这种情况
        return TEEC_ERROR_OUT_OF_MEMORY;
    }
    char * filename = (char *) (*env)->GetStringUTFChars(env, jFilename, 0);

    res = read_secure_object(filename, buffer, buffer_size, &file_size);
    // 释放内存
    (*env)->ReleaseStringUTFChars(env, jFilename, filename);
    // 最后一个参数mode=0表示要求将对数组的修改返回到Java层入参jBuffer里
    (*env)->ReleaseByteArrayElements(env, jBuffer, buffer, 0);

    // 读取成功，则返回读取的字节数（实际上就是文件大小），此时返回值为正数
    // 其他任何失败，返回错误码，此时返回值为负数，Java层可以根据返回值的正负来做对应处理
    return TEEC_SUCCESS == res ? file_size : res;
}

1
2
3

void GetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
jbyte* GetByteArrayElements(JNIEnv *env, jbyteArray array, jboolean *isCopy);
void* GetPrimitiveArrayCritical(JNIEnv *env, jobject array, jboolean *isCopy);