* Copyright (c) 2025 Huawei Device Co., Ltd.
* 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 "cmcertmanagercheck_fuzzer.h"
#include <cstring>
#include "cert_manager.h"
#include "cert_manager_api.h"
#include "cert_manager_app_cert_process.h"
#include "cm_cert_data_user.h"
#include "cm_fuzz_test_common.h"
#include "cm_test_common.h"
#include "cm_cert_data_ecc.h"
#include "cm_cert_data_part1_rsa.h"
#include "cm_x509.h"
#include "cert_manager_check.h"
#define MAX_OUT_BLOB_SIZE (5 * 1024 * 1024)
namespace {
const struct CmBlob g_eccAppCert = { sizeof(g_eccP256P12CertInfo), const_cast<uint8_t *>(g_eccP256P12CertInfo) };
const struct CmBlob g_appCertPwd = { sizeof(g_certPwd), const_cast<uint8_t *>(g_certPwd) };
const uint32_t UINT32_COUNT = 4;
const uint32_t CM_BLOB_COUNT = 2;
const uint32_t CHECK_UID_VALUE = 2;
}
using namespace CmFuzzTest;
namespace OHOS {
struct BufferParams {
uint8_t* myData;
uint32_t* remainSize;
uint32_t* offset;
};
struct StoreCertInfo {
uint32_t store;
uint32_t certNum;
bool isCheckUid;
};
class BufferReader {
public:
static bool ReadUintFromBuffer(BufferParams& params, uint32_t* value)
{
return GetUintFromBuffer(params.myData, params.remainSize, params.offset, value);
}
static bool ReadStoreAndCertInfo(BufferParams& params, StoreCertInfo& info)
{
if (!ReadUintFromBuffer(params, &info.store)) {
return false;
}
if (!ReadUintFromBuffer(params, &info.certNum)) {
return false;
}
info.isCheckUid = info.store % CHECK_UID_VALUE;
const uint32_t STORE_VALUE = 5;
info.store %= STORE_VALUE;
return true;
}
};
class ServiceChecker {
public:
static void ExecuteServiceChecks(struct CmBlob* uri, uint32_t store, bool isCheckUid,
struct CmAppCertParam* appCertParam, struct CmContext* cmContext)
{
(void)CheckUri(uri);
(void)CmServiceGetSystemCertListCheck(store);
(void)CmServiceGetSystemCertCheck(store, uri);
(void)CmServiceSetCertStatusCheck(store, uri, store);
(void)CmServiceInstallAppCertCheck(appCertParam, cmContext);
(void)CmServiceGetUserCertInfoCheck(cmContext, uri, store, isCheckUid);
(void)CmServiceUninstallAppCertCheck(cmContext, store, uri);
(void)CmServiceGetAppCertListCheck(cmContext, store);
(void)CmServiceGetCallingAppCertListCheck(cmContext, store);
(void)CmServiceGetAppCertCheck(cmContext, store, uri);
(void)CmServiceUninstallUserCertCheck(cmContext, uri);
(void)CmServiceSetUserCertStatusCheck(cmContext, uri);
}
};
static bool GenerateRandomUri(const char* retUriBuf, uint8_t* myData,
uint32_t* remainSize, uint32_t* offset,
struct CmBlob* randomUri)
{
char* random = nullptr;
if (!GetDynamicStringFromBuffer(myData, remainSize, offset, &random)) {
return false;
}
std::string randomString = std::string(retUriBuf) + random;
size_t len = randomString.length();
uint8_t* heapData = new uint8_t[len + 1];
std::copy(randomString.c_str(), randomString.c_str() + len, heapData);
heapData[len] = '\0';
*randomUri = {len, heapData};
delete[] random;
return true;
}
bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
{
uint32_t minSize = sizeof(struct CmBlob) * CM_BLOB_COUNT +sizeof(uint32_t) * UINT32_COUNT;
uint8_t *myData = nullptr;
if (!CopyMyData(data, size, minSize, &myData)) {
return false;
}
uint32_t remainSize = static_cast<uint32_t>(size);
uint32_t offset = 0;
char retUriBuf[MAX_OUT_BLOB_SIZE] = {0};
struct CmBlob keyUri = {sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
uint8_t certAliasBuf[] = "PrivKeyA";
struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
struct CmBlob privKey = { 0, NULL };
struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
&certAlias, CM_CREDENTIAL_STORE, INIT_INVALID_VALUE, CM_AUTH_STORAGE_LEVEL_EL2,
FILE_P12, &privKey, DEFAULT_FORMAT };
uint32_t uid = 20020156;
uint32_t userId = 100;
CmContext cmContext;
cmContext.uid = uid;
cmContext.userId = userId;
if (CertManagerInitialize() != 0) {
CmFree(myData);
return false;
}
BufferParams bufferParams = {myData, &remainSize, &offset};
StoreCertInfo storeInfo;
if (!BufferReader::ReadStoreAndCertInfo(bufferParams, storeInfo)) {
CmFree(myData);
return false;
}
CmInstallAppCertPro(&cmContext, &appCertParam, &keyUri);
struct CmAppUidList appUidList = { MAX_OUT_BLOB_SIZE + 1, nullptr };
CmGetAuthorizedAppList(&keyUri, &appUidList);
CertmanagerTest::MockHapToken mockHap;
ServiceChecker::ExecuteServiceChecks(&keyUri, storeInfo.store, storeInfo.isCheckUid, &appCertParam, &cmContext);
(void)CheckInstallMultiCertCount(&cmContext, storeInfo.certNum);
struct CmBlob randomUri;
if (!GenerateRandomUri(retUriBuf, myData, &remainSize, &offset, &randomUri)) {
CmFree(myData);
return false;
}
ServiceChecker::ExecuteServiceChecks(&randomUri, storeInfo.store,
storeInfo.isCheckUid, &appCertParam, &cmContext);
(void)CmUninstallAppCert(&keyUri, CM_CREDENTIAL_STORE);
CmFree(myData);
delete[] randomUri.data;
return true;
}
bool DoSomethingInterestingWithMyAPICmService(const uint8_t* data, size_t size)
{
uint32_t minSize = sizeof(struct CmBlob) * CM_BLOB_COUNT +sizeof(uint32_t) * UINT32_COUNT;
uint8_t *myData = nullptr;
if (!CopyMyData(data, size, minSize, &myData)) {
return false;
}
uint32_t remainSize = static_cast<uint32_t>(size);
uint32_t offset = 0;
uint32_t userId = 100;
CmContext cmContext;
cmContext.userId = userId;
if (CertManagerInitialize() != 0) {
CmFree(myData);
return false;
}
BufferParams bufferParams = {myData, &remainSize, &offset};
uint32_t store;
if (!BufferReader::ReadUintFromBuffer(bufferParams, &store)) {
CmFree(myData);
return false;
}
bool isCheckUid = store % CHECK_UID_VALUE;
struct CmBlob userCertTest = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
std::string alias = "alias_user";
char *aliasBuf = const_cast<char *>(alias.c_str());
struct CmBlob certAliasTest = { alias.length() + 1, reinterpret_cast<uint8_t *>(aliasBuf) };
CertmanagerTest::MockHapToken mockHap;
(void)CmServiceInstallUserCertCheck(&cmContext, &userCertTest, &certAliasTest, userId, isCheckUid);
(void)CmUninstallAppCert(&certAliasTest, CM_CREDENTIAL_STORE);
CmFree(myData);
return true;
}
}
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
OHOS::DoSomethingInterestingWithMyAPI(data, size);
OHOS::DoSomethingInterestingWithMyAPICmService(data, size);
return 0;
}