• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <stdlib.h>
17 #include "securec.h"
18 #include "device_attest_oem_file.h"
19 #include "device_attest_oem_adapter.h"
20 
21 static const char g_tokenMagicNum[] = {1, 2, 3, 4};
22 #define TOKEN_MAGIC_NUM_SIZE (sizeof(g_tokenMagicNum)/sizeof(g_tokenMagicNum[0]))
23 
ReadTokenWithFlag(char * path,char * fileName,char * result,unsigned int len)24 static int ReadTokenWithFlag(char* path, char* fileName, char* result, unsigned int len)
25 {
26     const unsigned int buffLen = TOKEN_MAGIC_NUM_SIZE + TOKEN_WITH_FLAG_SIZE + 1;
27     char buf[buffLen];
28     (void)memset_s(buf, buffLen, 0, buffLen);
29     if (OEMReadFile(path, fileName, buf, buffLen) != 0) {
30         return DEVICE_ATTEST_OEM_ERR;
31     }
32     int isTokenValid = 1;
33     for (unsigned int i = 0; i < TOKEN_MAGIC_NUM_SIZE; i++) {
34         if (buf[i] != g_tokenMagicNum[i]) {
35             isTokenValid = 0;
36             break;
37         }
38     }
39     if (isTokenValid == 0) {
40         return DEVICE_ATTEST_OEM_ERR;
41     }
42     (void)memcpy_s(result, TOKEN_WITH_FLAG_SIZE, buf + TOKEN_MAGIC_NUM_SIZE, TOKEN_WITH_FLAG_SIZE);
43     return DEVICE_ATTEST_OEM_OK;
44 }
45 
WriteTokenWithFlag(char * path,char * fileName,const char * tokenWithFlag,unsigned int len)46 static int WriteTokenWithFlag(char* path, char* fileName, const char* tokenWithFlag, unsigned int len)
47 {
48     const unsigned int buffLen = TOKEN_MAGIC_NUM_SIZE + TOKEN_WITH_FLAG_SIZE + 1;
49     char buf[buffLen];
50     (void)memset_s(buf, buffLen, 0, buffLen);
51 
52     for (unsigned int i = 0; i < TOKEN_MAGIC_NUM_SIZE; i++) {
53         buf[i] = g_tokenMagicNum[i];
54     }
55     (void)memcpy_s(buf + TOKEN_MAGIC_NUM_SIZE, TOKEN_WITH_FLAG_SIZE, tokenWithFlag, TOKEN_WITH_FLAG_SIZE);
56 
57     if (OEMCreateFile(path, fileName) != 0) {
58         return DEVICE_ATTEST_OEM_ERR;
59     }
60     return OEMWriteFile(path, fileName, buf, buffLen);
61 }
62 
GetTokenFlag(const char tokenWithFlag[])63 static uint32_t GetTokenFlag(const char tokenWithFlag[])
64 {
65     unsigned result = 0;
66     for (unsigned int i = 0; i < TOKEN_FLAG_SIZE; i++) {
67         result |= ((uint8_t)tokenWithFlag[TOKEN_SIZE + i]) << ((TOKEN_FLAG_SIZE - 1 - i) * BITS_PER_BYTE);
68     }
69     return result;
70 }
71 
SetTokenFlag(unsigned char flag[],uint32_t value)72 static void SetTokenFlag(unsigned char flag[], uint32_t value)
73 {
74     for (unsigned int i = 0; i < TOKEN_FLAG_SIZE; i++) {
75         flag[i] = (value >> (BITS_PER_BYTE * (TOKEN_FLAG_SIZE - 1 - i))) & 0xFF;
76     }
77 }
78 
OEMReadToken(char * token,uint32_t len)79 int32_t OEMReadToken(char *token, uint32_t len)
80 {
81     if (token == NULL || len == 0) {
82         return DEVICE_ATTEST_OEM_ERR;
83     }
84     char tokenWithFlagA[TOKEN_WITH_FLAG_SIZE] = {0};
85     char tokenWithFlagB[TOKEN_WITH_FLAG_SIZE] = {0};
86     int32_t retA = ReadTokenWithFlag(TOKEN_ADDR, TOKEN_A_ADDR, tokenWithFlagA, TOKEN_WITH_FLAG_SIZE);
87     int32_t retB = ReadTokenWithFlag(TOKEN_ADDR, TOKEN_B_ADDR, tokenWithFlagB, TOKEN_WITH_FLAG_SIZE);
88     if ((retA != DEVICE_ATTEST_OEM_OK) && (retB != DEVICE_ATTEST_OEM_OK)) {
89         return DEVICE_ATTEST_OEM_UNPRESET;
90     } else if ((retA == DEVICE_ATTEST_OEM_OK) && (retB != DEVICE_ATTEST_OEM_OK)) {
91         (void)memcpy_s(token, len, tokenWithFlagA, len);
92         return DEVICE_ATTEST_OEM_OK;
93     } else if ((retA != DEVICE_ATTEST_OEM_OK) && (retB == DEVICE_ATTEST_OEM_OK)) {
94         (void)memcpy_s(token, len, tokenWithFlagB, len);
95         return DEVICE_ATTEST_OEM_OK;
96     } else {
97         uint32_t flagA = GetTokenFlag(tokenWithFlagA);
98         uint32_t flagB = GetTokenFlag(tokenWithFlagB);
99         if (flagA > flagB) {
100             (void)memcpy_s(token, len, tokenWithFlagA, len);
101             return DEVICE_ATTEST_OEM_OK;
102         } else {
103             (void)memcpy_s(token, len, tokenWithFlagB, len);
104             return DEVICE_ATTEST_OEM_OK;
105         }
106     }
107 }
108 
OEMWriteToken(const char * token,uint32_t len)109 int32_t OEMWriteToken(const char *token, uint32_t len)
110 {
111     if (token == NULL || len == 0) {
112         return DEVICE_ATTEST_OEM_ERR;
113     }
114     char tokenWithFlagA[TOKEN_WITH_FLAG_SIZE] = {0};
115     char tokenWithFlagB[TOKEN_WITH_FLAG_SIZE] = {0};
116     int32_t retA = ReadTokenWithFlag(TOKEN_ADDR, TOKEN_A_ADDR, tokenWithFlagA, TOKEN_WITH_FLAG_SIZE);
117     int32_t retB = ReadTokenWithFlag(TOKEN_ADDR, TOKEN_B_ADDR, tokenWithFlagB, TOKEN_WITH_FLAG_SIZE);
118     if ((retA != DEVICE_ATTEST_OEM_OK) && (retB != DEVICE_ATTEST_OEM_OK)) {
119         unsigned char flag[TOKEN_FLAG_SIZE] = {0};
120         if ((memcpy_s(tokenWithFlagA, TOKEN_WITH_FLAG_SIZE, token, len) != 0) ||
121             (memcpy_s(tokenWithFlagA + len, TOKEN_WITH_FLAG_SIZE - len, flag, TOKEN_FLAG_SIZE) != 0)) {
122             return DEVICE_ATTEST_OEM_ERR;
123         }
124         if (WriteTokenWithFlag(TOKEN_ADDR, TOKEN_A_ADDR, tokenWithFlagA, TOKEN_WITH_FLAG_SIZE) != 0) {
125             return DEVICE_ATTEST_OEM_ERR;
126         }
127         return DEVICE_ATTEST_OEM_OK;
128     } else if ((retA == DEVICE_ATTEST_OEM_OK) && (retB != DEVICE_ATTEST_OEM_OK)) {
129         (void)memset_s(tokenWithFlagB, TOKEN_WITH_FLAG_SIZE, 0, TOKEN_WITH_FLAG_SIZE);
130         uint32_t flagA = GetTokenFlag(tokenWithFlagA);
131         unsigned char flag[TOKEN_FLAG_SIZE] = {0};
132         SetTokenFlag(flag, (uint32_t)(flagA + 1));
133         if ((memcpy_s(tokenWithFlagB, TOKEN_WITH_FLAG_SIZE, token, len) != 0) ||
134             (memcpy_s(tokenWithFlagB + len, TOKEN_WITH_FLAG_SIZE - len, flag, TOKEN_FLAG_SIZE) != 0)) {
135             return DEVICE_ATTEST_OEM_ERR;
136         }
137         if (WriteTokenWithFlag(TOKEN_ADDR, TOKEN_B_ADDR, tokenWithFlagB, TOKEN_WITH_FLAG_SIZE) != 0) {
138             return DEVICE_ATTEST_OEM_ERR;
139         }
140         return DEVICE_ATTEST_OEM_OK;
141     } else if ((retA != DEVICE_ATTEST_OEM_OK) && (retB == DEVICE_ATTEST_OEM_OK)) {
142         (void)memset_s(tokenWithFlagA, TOKEN_WITH_FLAG_SIZE, 0, TOKEN_WITH_FLAG_SIZE);
143         uint32_t flagB = GetTokenFlag(tokenWithFlagB);
144         unsigned char flag[TOKEN_FLAG_SIZE] = {0};
145         SetTokenFlag(flag, (uint32_t)(flagB + 1));
146         if ((memcpy_s(tokenWithFlagA, TOKEN_WITH_FLAG_SIZE, token, len) != 0) ||
147             (memcpy_s(tokenWithFlagA + len, TOKEN_WITH_FLAG_SIZE - len, flag, TOKEN_FLAG_SIZE) != 0)) {
148             return DEVICE_ATTEST_OEM_ERR;
149         }
150         if (WriteTokenWithFlag(TOKEN_ADDR, TOKEN_A_ADDR, tokenWithFlagA, TOKEN_WITH_FLAG_SIZE) != 0) {
151             return DEVICE_ATTEST_OEM_ERR;
152         }
153         return DEVICE_ATTEST_OEM_OK;
154     } else {
155         uint32_t flagA = GetTokenFlag(tokenWithFlagA);
156         uint32_t flagB = GetTokenFlag(tokenWithFlagB);
157         if (flagA > flagB) {
158             (void)memset_s(tokenWithFlagB, TOKEN_WITH_FLAG_SIZE, 0, TOKEN_WITH_FLAG_SIZE);
159             unsigned char flag[TOKEN_FLAG_SIZE] = {0};
160             SetTokenFlag(flag, (uint32_t)(flagA + 1));
161             if ((memcpy_s(tokenWithFlagB, TOKEN_WITH_FLAG_SIZE, token, len) != 0) ||
162                 (memcpy_s(tokenWithFlagB + len, TOKEN_WITH_FLAG_SIZE - len, flag, TOKEN_FLAG_SIZE) != 0)) {
163                 return DEVICE_ATTEST_OEM_ERR;
164             }
165             if (WriteTokenWithFlag(TOKEN_ADDR, TOKEN_B_ADDR, tokenWithFlagB, TOKEN_WITH_FLAG_SIZE) != 0) {
166                 return DEVICE_ATTEST_OEM_ERR;
167             }
168             return DEVICE_ATTEST_OEM_OK;
169         } else {
170             (void)memset_s(tokenWithFlagA, TOKEN_WITH_FLAG_SIZE, 0, TOKEN_WITH_FLAG_SIZE);
171             unsigned char flag[TOKEN_FLAG_SIZE] = {0};
172             SetTokenFlag(flag, (uint32_t)(flagB + 1));
173             if ((memcpy_s(tokenWithFlagA, TOKEN_WITH_FLAG_SIZE, token, len) != 0) ||
174                 (memcpy_s(tokenWithFlagA + len, TOKEN_WITH_FLAG_SIZE - len, flag, TOKEN_FLAG_SIZE) != 0)) {
175                 return DEVICE_ATTEST_OEM_ERR;
176             }
177             if (WriteTokenWithFlag(TOKEN_ADDR, TOKEN_A_ADDR, tokenWithFlagA, TOKEN_WITH_FLAG_SIZE) != 0) {
178                 return DEVICE_ATTEST_OEM_ERR;
179             }
180             return DEVICE_ATTEST_OEM_OK;
181         }
182     }
183 }
184 
OEMGetManufacturekey(char * manufacturekey,uint32_t len)185 int32_t OEMGetManufacturekey(char* manufacturekey, uint32_t len)
186 {
187     if ((manufacturekey == NULL) || (len == 0)) {
188         return DEVICE_ATTEST_OEM_ERR;
189     }
190     const char manufacturekeyBuf[] = {
191         0x13, 0x42, 0x3F, 0x3F, 0x53, 0x3F, 0x72, 0x30, 0x3F, 0x3F, 0x1C, 0x3F, 0x2F, 0x3F, 0x2E, 0x42,
192         0x3F, 0x08, 0x3F, 0x57, 0x3F, 0x10, 0x3F, 0x3F, 0x29, 0x17, 0x52, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
193         0x57, 0x16, 0x3F, 0x7D, 0x4A, 0x0F, 0x3F, 0x3F, 0x3F, 0x30, 0x0C, 0x3F, 0x3F, 0x4C, 0x3F, 0x47
194     };
195     uint32_t manufacturekeyBufLen = sizeof(manufacturekeyBuf);
196     if (len < manufacturekeyBufLen) {
197         return DEVICE_ATTEST_OEM_ERR;
198     }
199 
200     int32_t ret = memcpy_s(manufacturekey, len, manufacturekeyBuf, manufacturekeyBufLen);
201     return ret;
202 }
203 
OEMGetProductId(char * productId,uint32_t len)204 int32_t OEMGetProductId(char* productId, uint32_t len)
205 {
206     if ((productId == NULL) || (len == 0)) {
207         return DEVICE_ATTEST_OEM_ERR;
208     }
209     const char productIdBuf[] = "OH00000D";
210     uint32_t productIdLen = strlen(productIdBuf);
211     if (len < productIdLen) {
212         return DEVICE_ATTEST_OEM_ERR;
213     }
214 
215     int32_t ret = memcpy_s(productId, len, productIdBuf, productIdLen);
216     return ret;
217 }
218 
219 /* It is temporarily useless */
OEMGetProductKey(char * productKey,uint32_t len)220 int32_t OEMGetProductKey(char* productKey, uint32_t len)
221 {
222     if ((productKey == NULL) || (len == 0)) {
223         return DEVICE_ATTEST_OEM_ERR;
224     }
225     const char productKeyBuf[] = "test";
226     uint32_t productKeyLen = sizeof(productKeyBuf);
227     if (len < productKeyLen) {
228         return DEVICE_ATTEST_OEM_ERR;
229     }
230 
231     int32_t ret = memcpy_s(productKey, len, productKeyBuf, productKeyLen);
232     return ret;
233 }
234