1 /*
2 * Copyright (c) 2022-2025 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 #ifndef CM_TYPE_H
17 #define CM_TYPE_H
18
19 #include <stdbool.h>
20 #include <stdint.h>
21 #include <stdlib.h>
22
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26 #ifndef CM_API_PUBLIC
27 #if defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) || defined(__ICCARM__) /* __ICCARM__ for iar */
28 #define CM_API_EXPORT
29 #else
30 #define CM_API_EXPORT __attribute__ ((visibility("default")))
31 #endif
32 #else
33 #define CM_API_EXPORT __attribute__ ((visibility("default")))
34 #endif
35
36 #define MAX_LEN_CERTIFICATE 8196
37 #define MAX_LEN_CERTIFICATE_P7B (1024 * 300)
38
39 #define MAX_LEN_CERTIFICATE_CHAIN (3 * MAX_LEN_CERTIFICATE)
40
41 #define MAX_SUFFIX_LEN 16
42 #define MAX_COUNT_CERTIFICATE 256
43 #define MAX_COUNT_CERTIFICATE_ALL 512
44 #define MAX_P7B_INSTALL_COUNT 256
45 #define MAX_LEN_URI 256
46 #define MAX_AUTH_LEN_URI 256
47 #define MAX_LEN_CERT_ALIAS 129 /* include 1 byte: the terminator('\0') */
48 #define MAX_LEN_SUBJECT_NAME 1025 /* include 1 byte: the terminator('\0') */
49 #define MAX_LEN_PACKGE_NAME 64
50 #define MAX_LEN_MAC_KEY 64
51 #define MAX_UINT32_LEN 16
52 #define MAX_LEN_CERT_TYPE 8
53 #define MAX_LEN_PRI_CRED_ALIAS 33 /* include 1 byte: the terminator('\0') */
54
55 #define MAX_LEN_ISSUER_NAME 256
56 #define MAX_LEN_SERIAL 64
57 #define MAX_LEN_NOT_BEFORE 32
58 #define MAX_LEN_NOT_AFTER 32
59 #define MAX_LEN_FINGER_PRINT_SHA256 128
60 #define MAX_LEN_APP_CERT 20480
61 #define MAX_LEN_APP_CERT_PASSWD 33 /* 32位密码 + 1位结束符 */
62
63 #define CERT_MAX_PATH_LEN 256
64 #define CM_ARRAY_SIZE(arr) ((sizeof(arr)) / (sizeof((arr)[0])))
65 #define INIT_INVALID_VALUE 0xFFFFFFFF
66
67 #define CERT_STATUS_ENABLED ((uint32_t) 0)
68 #define CERT_STATUS_DISABLED ((uint32_t) 1)
69
70 #define ERROR_LEVEL 0
71
72 /*
73 * Align to 4-tuple
74 * Before calling this function, ensure that the size does not overflow after 3 is added.
75 */
76 #define ALIGN_SIZE(size) ((((uint32_t)(size) + 3) >> 2) << 2)
77
78 #define CM_BITS_PER_BYTE 8
79 #define CM_KEY_BYTES(keySize) (((keySize) + CM_BITS_PER_BYTE - 1) / CM_BITS_PER_BYTE)
80 #define MAX_OUT_BLOB_SIZE (5 * 1024 * 1024)
81
82 #define CM_CREDENTIAL_STORE 0
83 #define CM_SYSTEM_TRUSTED_STORE 1
84 #define CM_USER_TRUSTED_STORE 2
85 #define CM_PRI_CREDENTIAL_STORE 3
86 #define CM_SYS_CREDENTIAL_STORE 4
87 #define CM_STORE_CHECK(a) \
88 (((a) != CM_CREDENTIAL_STORE) && ((a) != CM_PRI_CREDENTIAL_STORE) && ((a) != CM_SYS_CREDENTIAL_STORE))
89 #define CM_LEVEL_CHECK(a) \
90 (((a) != CM_AUTH_STORAGE_LEVEL_EL1) && ((a) != CM_AUTH_STORAGE_LEVEL_EL2) && ((a) != CM_AUTH_STORAGE_LEVEL_EL4))
91
92 #define CA_STORE_PATH_SYSTEM "/etc/security/certificates"
93 #define CA_STORE_PATH_SYSTEM_SM "/etc/security/certificates_gm"
94 #define SYSTEM_CA_STORE_GM "/system/etc/security/certificates_gm/"
95 #define CA_STORE_PATH_USER_SANDBOX_BASE "/data/certificates/user_cacerts/"
96 #define CA_STORE_PATH_USER_SERVICE_BASE "/data/service/el1/public/cert_manager_service/certificates/user_open/"
97
98 enum CmKeyDigest {
99 CM_DIGEST_NONE = 0,
100 CM_DIGEST_MD5 = 1,
101 CM_DIGEST_SM3 = 2,
102 CM_DIGEST_SHA1 = 10,
103 CM_DIGEST_SHA224 = 11,
104 CM_DIGEST_SHA256 = 12,
105 CM_DIGEST_SHA384 = 13,
106 CM_DIGEST_SHA512 = 14,
107 };
108
109 enum CmKeyPurpose {
110 CM_KEY_PURPOSE_ENCRYPT = 1, /* Usable with RSA, EC, AES, and SM4 keys. */
111 CM_KEY_PURPOSE_DECRYPT = 2, /* Usable with RSA, EC, AES, and SM4 keys. */
112 CM_KEY_PURPOSE_SIGN = 4, /* Usable with RSA, EC keys. */
113 CM_KEY_PURPOSE_VERIFY = 8, /* Usable with RSA, EC keys. */
114 CM_KEY_PURPOSE_DERIVE = 16, /* Usable with EC keys. */
115 CM_KEY_PURPOSE_WRAP = 32, /* Usable with wrap key. */
116 CM_KEY_PURPOSE_UNWRAP = 64, /* Usable with unwrap key. */
117 CM_KEY_PURPOSE_MAC = 128, /* Usable with mac. */
118 CM_KEY_PURPOSE_AGREE = 256, /* Usable with agree. */
119 };
120
121 enum CmKeyPadding {
122 CM_PADDING_NONE = 0,
123 CM_PADDING_OAEP = 1,
124 CM_PADDING_PSS = 2,
125 CM_PADDING_PKCS1_V1_5 = 3,
126 CM_PADDING_PKCS5 = 4,
127 CM_PADDING_PKCS7 = 5,
128 };
129
130 enum CmErrorCode {
131 CM_SUCCESS = 0,
132 CM_FAILURE = -1,
133
134 CMR_ERROR_NOT_PERMITTED = -2,
135 CMR_ERROR_NOT_SUPPORTED = -3,
136 CMR_ERROR_STORAGE = -4,
137 CMR_ERROR_NOT_FOUND = -5,
138 CMR_ERROR_NULL_POINTER = -6,
139 CMR_ERROR_INVALID_ARGUMENT = -7,
140 CMR_ERROR_MAKE_DIR_FAIL = -8,
141 CMR_ERROR_INVALID_OPERATION = -9,
142 CMR_ERROR_OPEN_FILE_FAIL = -10,
143 CMR_ERROR_READ_FILE_ERROR = -11,
144 CMR_ERROR_WRITE_FILE_FAIL = -12,
145 CMR_ERROR_REMOVE_FILE_FAIL = -13,
146 CMR_ERROR_CLOSE_FILE_FAIL = -14,
147 CMR_ERROR_MALLOC_FAIL = -15,
148 CMR_ERROR_NOT_EXIST = -16,
149 CMR_ERROR_ALREADY_EXISTS = -17,
150 CMR_ERROR_INSUFFICIENT_DATA = -18,
151 CMR_ERROR_BUFFER_TOO_SMALL = -19,
152 CMR_ERROR_INVALID_CERT_FORMAT = -20,
153 CMR_ERROR_PARAM_NOT_EXIST = -21,
154 CMR_ERROR_SESSION_REACHED_LIMIT = -22,
155 CMR_ERROR_PERMISSION_DENIED = -23,
156 CMR_ERROR_AUTH_CHECK_FAILED = -24,
157 CMR_ERROR_KEY_OPERATION_FAILED = -25,
158 CMR_ERROR_NOT_SYSTEMP_APP = -26,
159 CMR_ERROR_MAX_CERT_COUNT_REACHED = -27,
160 CMR_ERROR_ALIAS_LENGTH_REACHED_LIMIT = -28,
161 CMR_ERROR_GET_ADVSECMODE_PARAM_FAIL = -29,
162 CMR_ERROR_DEVICE_ENTER_ADVSECMODE = -30,
163 CMR_ERROR_CREATE_RDB_TABLE_FAIL = -31,
164 CMR_ERROR_INSERT_RDB_DATA_FAIL = -32,
165 CMR_ERROR_UPDATE_RDB_DATA_FAIL = -33,
166 CMR_ERROR_DELETE_RDB_DATA_FAIL = -34,
167 CMR_ERROR_QUERY_RDB_DATA_FAIL = -35,
168 CMR_ERROR_PASSWORD_IS_ERR = -36,
169
170 CMR_ERROR_OPENSSL_FAIL = -37,
171 CMR_ERROR_MAX_GRANT_COUNT_REACHED = -38,
172 CMR_ERROR_SA_START_STATUS_INIT_FAILED = -39,
173 CMR_ERROR_SA_START_HUKS_INIT_FAILED = -40,
174 CMR_ERROR_SA_START_PUBLISH_FAILED = -41,
175 CMR_ERROR_IPC_PARAM_SIZE_INVALID = -42,
176 CMR_ERROR_GET_LOCAL_TIME_FAILED = -43,
177 CMR_ERROR_MEM_OPERATION_COPY = -44,
178 CMR_ERROR_MEM_OPERATION_PRINT = -45,
179 CMR_ERROR_FILE_OPEN_DIR = -46,
180 CMR_ERROR_FILE_STAT = -47,
181 CMR_ERROR_CERT_COUNT_MISMATCH = -48,
182 CMR_ERROR_GET_CERT_STATUS = -49,
183 CMR_ERROR_GET_CERT_SUBJECT_ITEM = -50,
184
185 /* invalid argument */
186 CMR_ERROR_INVALID_ARGUMENT_BEGIN = -10000,
187 CMR_ERROR_INVALID_PARAMSET_ARG = -10001,
188 CMR_ERROR_INVALID_ARGUMENT_STORE_TYPE = -10002,
189 CMR_ERROR_INVALID_ARGUMENT_SCOPE = -10003,
190 CMR_ERROR_INVALID_ARGUMENT_USER_ID = -10004,
191 CMR_ERROR_INVALID_ARGUMENT_UID = -10005,
192 CMR_ERROR_INVALID_ARGUMENT_URI = -10006,
193 CMR_ERROR_INVALID_ARGUMENT_STATUS = -10007,
194 CMR_ERROR_INVALID_ARGUMENT_APP_CERT = -10008,
195 CMR_ERROR_INVALID_ARGUMENT_APP_PWD = -10009,
196 CMR_ERROR_INVALID_ARGUMENT_ALIAS = -10010,
197 CMR_ERROR_INVALID_ARGUMENT_SIGN_SPEC = -10011,
198 CMR_ERROR_INVALID_ARGUMENT_HANDLE = -10012,
199 CMR_ERROR_INVALID_ARGUMENT_END = -19999,
200
201 /* key operation failed */
202 CMR_ERROR_KEY_OPERATION_BEGIN = -20000,
203 CMR_ERROR_KEY_IMPORT_PARAM_FAILED = -20001,
204 CMR_ERROR_KEY_IMPORT_FAILED = -20002,
205 CMR_ERROR_KEY_DELETE_PARAM_FAILED = -20003,
206 CMR_ERROR_KEY_DELETE_FAILED = -20004,
207 CMR_ERROR_KEY_MAC_PARAM_FAILED = -20005,
208 CMR_ERROR_KEY_MAC_INIT_FAILED = -20006,
209 CMR_ERROR_KEY_MAC_FINISH_FAILED = -20007,
210 CMR_ERROR_KEY_GENERATE_PARAM_FAILED = -20008,
211 CMR_ERROR_KEY_GENERATE_FAILED = -20009,
212 CMR_ERROR_KEY_INIT_PARAM_FAILED = -20010,
213 CMR_ERROR_KEY_INIT_FAILED = -20011,
214 CMR_ERROR_KEY_PROCESS_PARAM_FAILED = -20012,
215 CMR_ERROR_KEY_UPDATE_FAILED = -20013,
216 CMR_ERROR_KEY_FINISH_FAILED = -20014,
217 CMR_ERROR_KEY_ABORT_FAILED = -20015,
218 CMR_ERROR_KEY_CHECK_EXIST_PARAM_FAILED = -20016,
219 CMR_ERROR_KEY_CHECK_EXIST_FAILED = -20017,
220 CMR_ERROR_KEY_OPERATION_END = -29999,
221
222 /* auth check failed */
223 CMR_ERROR_AUTH_FAILED_BEGIN = -30000,
224 CMR_ERROR_AUTH_FAILED_MAC_FAILED = -30001,
225 CMR_ERROR_AUTH_FAILED_MAC_MISMATCH = -30002,
226 CMR_ERROR_AUTH_FAILED_END = -39999,
227 };
228
229 enum CMDialogErrorCode {
230 CMR_DIALOG_ERROR_INSTALL_FAILED = -5,
231
232 CMR_DIALOG_ERROR_INTERNAL = -1000,
233 CMR_DIALOG_ERROR_OPERATION_CANCELS = -1001,
234 CMR_DIALOG_ERROR_PARSE_CERT_FAILED = -1002,
235 CMR_DIALOG_ERROR_NOT_ENTERPRISE_DEVICE = -1003,
236 CMR_DIALOG_ERROR_ADVANCED_SECURITY = -1004,
237 CMR_DIALOG_ERROR_INCORRECT_FORMAT = -1005,
238 CMR_DIALOG_ERROR_MAX_QUANTITY_REACHED = -1006,
239 CMR_DIALOG_ERROR_SA_INTERNAL_ERROR = -1007,
240 CMR_DIALOG_ERROR_NOT_EXIST = -1008,
241 CMR_DIALOG_ERROR_NOT_SUPPORTED = -1009,
242 CMR_DIALOG_ERROR_PARAM_INVALID = -1010,
243 CMR_DIALOG_ERROR_PERMISSION_DENIED = 1011, /* UIExtension will return 1011 if permission check failed */
244 };
245
246 enum CMErrorCode { /* temp use */
247 CMR_OK = 0,
248 CMR_ERROR = -1,
249 };
250
251 enum CmTagType {
252 CM_TAG_TYPE_INVALID = 0 << 28,
253 CM_TAG_TYPE_INT = 1 << 28,
254 CM_TAG_TYPE_UINT = 2 << 28,
255 CM_TAG_TYPE_ULONG = 3 << 28,
256 CM_TAG_TYPE_BOOL = 4 << 28,
257 CM_TAG_TYPE_BYTES = 5 << 28,
258 };
259
260 enum CmTag {
261 /* Inner-use TAGS used for ipc serialization */
262 CM_TAG_PARAM0_BUFFER = CM_TAG_TYPE_BYTES | 30001,
263 CM_TAG_PARAM1_BUFFER = CM_TAG_TYPE_BYTES | 30002,
264 CM_TAG_PARAM2_BUFFER = CM_TAG_TYPE_BYTES | 30003,
265 CM_TAG_PARAM3_BUFFER = CM_TAG_TYPE_BYTES | 30004,
266 CM_TAG_PARAM4_BUFFER = CM_TAG_TYPE_BYTES | 30005,
267 CM_TAG_PARAM0_UINT32 = CM_TAG_TYPE_UINT | 30006,
268 CM_TAG_PARAM1_UINT32 = CM_TAG_TYPE_UINT | 30007,
269 CM_TAG_PARAM2_UINT32 = CM_TAG_TYPE_UINT | 30008,
270 CM_TAG_PARAM3_UINT32 = CM_TAG_TYPE_UINT | 30009,
271 CM_TAG_PARAM4_UINT32 = CM_TAG_TYPE_UINT | 30010,
272 CM_TAG_PARAM0_BOOL = CM_TAG_TYPE_BOOL | 30011,
273 CM_TAG_PARAM1_BOOL = CM_TAG_TYPE_BOOL | 30012,
274 CM_TAG_PARAM2_BOOL = CM_TAG_TYPE_BOOL | 30013,
275 CM_TAG_PARAM3_BOOL = CM_TAG_TYPE_BOOL | 30014,
276 CM_TAG_PARAM4_BOOL = CM_TAG_TYPE_BOOL | 30015,
277 CM_TAG_PARAM0_NULL = CM_TAG_TYPE_BYTES | 30016,
278 CM_TAG_PARAM1_NULL = CM_TAG_TYPE_BYTES | 30017,
279 CM_TAG_PARAM2_NULL = CM_TAG_TYPE_BYTES | 30018,
280 CM_TAG_PARAM3_NULL = CM_TAG_TYPE_BYTES | 30019,
281 CM_TAG_PARAM4_NULL = CM_TAG_TYPE_BYTES | 30020,
282 };
283
284 #define CM_PARAM_BUFFER_NULL_INTERVAL ((CM_TAG_PARAM0_NULL) - (CM_TAG_PARAM0_BUFFER))
285
286 enum CmSendType {
287 CM_SEND_TYPE_ASYNC = 0,
288 CM_SEND_TYPE_SYNC,
289 };
290
291 struct CmMutableBlob {
292 uint32_t size;
293 uint8_t *data;
294 };
295
296 struct CmContext {
297 uint32_t userId;
298 uint32_t uid;
299 char packageName[MAX_LEN_PACKGE_NAME];
300 };
301
302 struct CmBlob {
303 uint32_t size;
304 uint8_t *data;
305 };
306
307 struct CertBlob {
308 struct CmBlob uri[MAX_COUNT_CERTIFICATE_ALL];
309 struct CmBlob certAlias[MAX_COUNT_CERTIFICATE_ALL];
310 struct CmBlob subjectName[MAX_COUNT_CERTIFICATE_ALL];
311 };
312
313 struct CmAppCertInfo {
314 struct CmBlob appCert;
315 struct CmBlob appCertPwd;
316 };
317
318 struct CertListAbtInfo {
319 uint32_t uriSize;
320 char uri[MAX_LEN_URI];
321 uint32_t aliasSize;
322 char certAlias[MAX_LEN_CERT_ALIAS];
323 uint32_t status;
324 uint32_t subjectNameSize;
325 char subjectName[MAX_LEN_SUBJECT_NAME];
326 };
327
328 struct CertAbstract {
329 char uri[MAX_LEN_URI];
330 char certAlias[MAX_LEN_CERT_ALIAS];
331 bool status;
332 char subjectName[MAX_LEN_SUBJECT_NAME];
333 };
334
335 struct CertList {
336 uint32_t certsCount;
337 struct CertAbstract *certAbstract;
338 };
339
340 struct CertAbtInfo {
341 uint32_t aliasSize;
342 char certAlias[MAX_LEN_CERT_ALIAS];
343 uint32_t status;
344 uint32_t certsize;
345 uint8_t certData[MAX_LEN_CERTIFICATE];
346 };
347
348 struct CertInfo {
349 char uri[MAX_LEN_URI];
350 char certAlias[MAX_LEN_CERT_ALIAS];
351 bool status;
352 char issuerName[MAX_LEN_ISSUER_NAME];
353 char subjectName[MAX_LEN_SUBJECT_NAME];
354 char serial[MAX_LEN_SERIAL];
355 char notBefore[MAX_LEN_NOT_BEFORE];
356 char notAfter[MAX_LEN_NOT_AFTER];
357 char fingerprintSha256[MAX_LEN_FINGER_PRINT_SHA256];
358 struct CmBlob certInfo;
359 };
360
361 struct CertFile {
362 const struct CmBlob *fileName;
363 const struct CmBlob *path;
364 };
365
366 struct CertFileInfo {
367 struct CmBlob fileName;
368 struct CmBlob path;
369 };
370
371 struct CMApp {
372 uint32_t userId;
373 uint32_t uid;
374 const char *packageName;
375 struct CmBlob *appId; // for attestation
376 };
377
378 struct Credential {
379 uint32_t isExist;
380 char type[MAX_LEN_SUBJECT_NAME];
381 char alias[MAX_LEN_CERT_ALIAS];
382 char keyUri[MAX_LEN_URI];
383 uint32_t certNum;
384 uint32_t keyNum;
385 struct CmBlob credData;
386 };
387
388 struct CredentialAbstract {
389 char type[MAX_LEN_SUBJECT_NAME];
390 char alias[MAX_LEN_CERT_ALIAS];
391 char keyUri[MAX_LEN_URI];
392 };
393
394 struct CredentialList {
395 uint32_t credentialCount;
396 struct CredentialAbstract *credentialAbstract;
397 };
398
399 struct AppCert {
400 uint32_t certCount;
401 uint32_t keyCount;
402 uint32_t certSize;
403 uint8_t appCertdata[MAX_LEN_CERTIFICATE_CHAIN];
404 };
405
406 struct CmParam {
407 uint32_t tag;
408 union {
409 bool boolParam;
410 int32_t int32Param;
411 uint32_t uint32Param;
412 uint64_t uint64Param;
413 struct CmBlob blob;
414 };
415 };
416
417 struct CmParamOut {
418 uint32_t tag;
419 union {
420 bool *boolParam;
421 int32_t *int32Param;
422 uint32_t *uint32Param;
423 uint64_t *uint64Param;
424 struct CmBlob *blob;
425 };
426 };
427
428 struct CmParamSet {
429 uint32_t paramSetSize;
430 uint32_t paramsCnt;
431 struct CmParam params[];
432 };
433
434 struct CmAppUidList {
435 uint32_t appUidCount;
436 uint32_t *appUid;
437 };
438
439 struct CmSignatureSpec {
440 uint32_t purpose;
441 uint32_t padding;
442 uint32_t digest;
443 };
444
445 enum CmAuthStorageLevel {
446 CM_AUTH_STORAGE_LEVEL_EL1 = 1,
447 CM_AUTH_STORAGE_LEVEL_EL2 = 2,
448 CM_AUTH_STORAGE_LEVEL_EL4 = 4,
449 };
450
451 struct CmAppCertParam {
452 struct CmBlob *appCert;
453 struct CmBlob *appCertPwd;
454 struct CmBlob *certAlias;
455 uint32_t store;
456 uint32_t userId;
457 enum CmAuthStorageLevel level;
458 };
459
460 struct CertName {
461 struct CmBlob *displayName;
462 struct CmBlob *objectName;
463 struct CmBlob *subjectName;
464 };
465
466 enum CmCertType {
467 CM_CA_CERT_SYSTEM = 0,
468 CM_CA_CERT_USER = 1,
469 };
470
471 enum CmCertScope {
472 CM_ALL_USER = 0,
473 CM_CURRENT_USER = 1,
474 CM_GLOBAL_USER = 2,
475 };
476
477 enum CmCertFileFormat {
478 PEM_DER = 0,
479 P7B = 1,
480 };
481
482 struct UserCAProperty {
483 uint32_t userId;
484 enum CmCertScope scope;
485 };
486
487 struct CmInstallCertInfo {
488 const struct CmBlob *userCert;
489 const struct CmBlob *certAlias;
490 uint32_t userId;
491 };
492
493 struct CertUriList {
494 uint32_t certCount;
495 struct CmBlob *uriList;
496 };
497
498 struct InstallUserCertParams {
499 struct CmContext *cmContext;
500 struct CmBlob *userCert;
501 struct CmBlob *certAlias;
502 struct CmBlob *outData;
503 uint32_t status;
504 };
505
CmIsAdditionOverflow(uint32_t a,uint32_t b)506 static inline bool CmIsAdditionOverflow(uint32_t a, uint32_t b)
507 {
508 return (UINT32_MAX - a) < b;
509 }
510
CmCheckBlob(const struct CmBlob * blob)511 static inline int32_t CmCheckBlob(const struct CmBlob *blob)
512 {
513 if ((blob == NULL) || (blob->data == NULL) || (blob->size == 0)) {
514 return CMR_ERROR_INVALID_ARGUMENT;
515 }
516 return CM_SUCCESS;
517 }
518
CmCheckInstallCertInfo(const struct CmInstallCertInfo * installCertInfo)519 static inline int32_t CmCheckInstallCertInfo(const struct CmInstallCertInfo *installCertInfo)
520 {
521 if (installCertInfo == NULL || CmCheckBlob(installCertInfo->certAlias) != CM_SUCCESS ||
522 CmCheckBlob(installCertInfo->userCert) != CM_SUCCESS) {
523 return CMR_ERROR_INVALID_ARGUMENT;
524 }
525 return CM_SUCCESS;
526 }
527
528 #ifdef __cplusplus
529 }
530 #endif
531
532 #endif /* CM_TYPE_H */
533