From fa67f83b90af8a5facdce69d520ca8a891dde006 Mon Sep 17 00:00:00 2001 From: wangpggg Date: Sat, 22 Mar 2025 11:18:26 +0800 Subject: [PATCH] modify fuzz Signed-off-by: wangpeng --- .../native/backup_ext/src/ext_extension.cpp | 1 + .../backup_ext/src/sub_ext_extension.cpp | 1 + .../native/backup_ext/src/untar_file.cpp | 2 +- .../backup_sa/src/module_ipc/sub_service.cpp | 3 +- test/fuzztest/servicereverse_fuzzer/BUILD.gn | 5 +- .../servicereverse_fuzzer.cpp | 676 +++++++++++++++--- .../bundle_dependencies/fileShareA/BUILD.gn | 4 +- .../bundle_dependencies/fileShareB/BUILD.gn | 4 +- 8 files changed, 596 insertions(+), 100 deletions(-) diff --git a/frameworks/native/backup_ext/src/ext_extension.cpp b/frameworks/native/backup_ext/src/ext_extension.cpp index 0fa51bd06..42043b085 100644 --- a/frameworks/native/backup_ext/src/ext_extension.cpp +++ b/frameworks/native/backup_ext/src/ext_extension.cpp @@ -17,6 +17,7 @@ #include #include +#include #include #include #include diff --git a/frameworks/native/backup_ext/src/sub_ext_extension.cpp b/frameworks/native/backup_ext/src/sub_ext_extension.cpp index afcaa1a10..07b049c19 100644 --- a/frameworks/native/backup_ext/src/sub_ext_extension.cpp +++ b/frameworks/native/backup_ext/src/sub_ext_extension.cpp @@ -17,6 +17,7 @@ #include #include +#include #include #include #include diff --git a/frameworks/native/backup_ext/src/untar_file.cpp b/frameworks/native/backup_ext/src/untar_file.cpp index 41b16c7e6..87d6f9454 100644 --- a/frameworks/native/backup_ext/src/untar_file.cpp +++ b/frameworks/native/backup_ext/src/untar_file.cpp @@ -674,7 +674,7 @@ std::tuple UntarFile::ParsePaxBlock() break; } string pathLen = content.substr(pos, lenEnd - pos); - recLen = std::atoi(pathLen.c_str()); + recLen = static_cast(std::atoi(pathLen.c_str())); allLen = recLen + OTHER_HEADER; if (allLen > BLOCK_SIZE) { isLongName = true; diff --git a/services/backup_sa/src/module_ipc/sub_service.cpp b/services/backup_sa/src/module_ipc/sub_service.cpp index b679afd82..6447557aa 100644 --- a/services/backup_sa/src/module_ipc/sub_service.cpp +++ b/services/backup_sa/src/module_ipc/sub_service.cpp @@ -16,8 +16,9 @@ #include "module_ipc/service.h" #include -#include #include +#include +#include #include #include #include diff --git a/test/fuzztest/servicereverse_fuzzer/BUILD.gn b/test/fuzztest/servicereverse_fuzzer/BUILD.gn index 83e4237e0..d55e2aef3 100644 --- a/test/fuzztest/servicereverse_fuzzer/BUILD.gn +++ b/test/fuzztest/servicereverse_fuzzer/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2021-2024 Huawei Device Co., Ltd. +# Copyright (c) 2021-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 @@ -48,7 +48,10 @@ ohos_fuzztest("ServiceReverseFuzzTest") { defines = [ "LOG_TAG=\"app_file_service\"", "LOG_DOMAIN=0xD200000", + "private=public", ] + + use_exceptions = true } ############################################################################### diff --git a/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp b/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp index dbba2c2f1..96cd65d2e 100644 --- a/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp +++ b/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-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 @@ -15,147 +15,591 @@ #include "servicereverse_fuzzer.h" -#include -#include -#include +#include -#include -#include "message_parcel.h" +#include "b_error/b_error.h" #include "b_session_backup.h" #include "b_session_restore.h" #include "b_incremental_backup_session.h" #include "b_incremental_restore_session.h" -#include "i_service_reverse_ipc_interface_code.h" +#include "message_parcel.h" #include "service_reverse_stub.h" #include "service_reverse.h" -#include "securec.h" - -using namespace OHOS::FileManagement::Backup; namespace OHOS { -constexpr size_t U32_AT_SIZE = 4; -constexpr uint8_t MAX_CALL_TRANSACTION = 24; -constexpr int32_t SHIFT_FIRST = 24; -constexpr int32_t SHIFT_SECOND = 16; -constexpr int32_t SHIFT_THIRD = 8; -constexpr int32_t ZERO_NUM = 0; -constexpr int32_t FIRST_NUM = 1; -constexpr int32_t SECOND_NUM = 2; -constexpr int32_t THIRD_NUM = 3; - -uint32_t ConvertToUint32(const uint8_t* ptr) -{ - if (ptr == nullptr) { - return 0; +using namespace std; +using namespace FileManagement::Backup; + +template +T TypeCast(const uint8_t *data, int *pos = nullptr) +{ + if (pos) { + *pos += sizeof(T); + } + return *(reinterpret_cast(data)); +} + +bool BackupOnFileReadyFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(bool) + sizeof(int)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int fd = TypeCast(data, &pos); + bool fdFlag = TypeCast(data, &pos); + int len = ((size - pos) >> 1); + msg.WriteString(string(reinterpret_cast(data + pos), len)); + msg.WriteString(string(reinterpret_cast(data + pos + len), size - pos - len)); + msg.WriteBool(fdFlag); + if (fdFlag) { + msg.WriteFileDescriptor(fd); + } + service->CmdBackupOnFileReady(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool BackupOnBundleStartedFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int32_t errCode = TypeCast(data, &pos); + msg.WriteInt32(errCode); + msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); + service->CmdBackupOnBundleStarted(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool BackupOnResultReportFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int len = (size >> 1); + msg.WriteString(string(reinterpret_cast(data), len)); + msg.WriteString(string(reinterpret_cast(data + len), size - len)); + service->CmdBackupOnResultReport(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool BackupOnBundleFinishedFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int32_t errCode = TypeCast(data, &pos); + msg.WriteInt32(errCode); + msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); + service->CmdBackupOnBundleFinished(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool BackupOnAllBundlesFinishedFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int32_t errCode = TypeCast(data); + msg.WriteInt32(errCode); + service->CmdBackupOnAllBundlesFinished(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool BackupOnProcessInfoFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int len = (size >> 1); + msg.WriteString(string(reinterpret_cast(data), len)); + msg.WriteString(string(reinterpret_cast(data + len), size - len)); + service->CmdBackupOnProcessInfo(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool BackupOnScanningInfoFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + msg.WriteString(string(reinterpret_cast(data), size)); + service->CmdBackupOnScanningInfo(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool RestoreOnBundleStartedFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int32_t errCode = TypeCast(data, &pos); + msg.WriteInt32(errCode); + msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); + service->CmdRestoreOnBundleStarted(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool RestoreOnBundleFinishedFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int32_t errCode = TypeCast(data, &pos); + msg.WriteInt32(errCode); + msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); + service->CmdRestoreOnBundleFinished(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool RestoreOnAllBundlesFinishedFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int32_t errCode = TypeCast(data); + msg.WriteInt32(errCode); + service->CmdRestoreOnAllBundlesFinished(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool RestoreOnFileReadyFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(bool) + sizeof(int) + sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int fd = TypeCast(data, &pos); + bool fdFlag = TypeCast(data, &pos); + int32_t errCode = TypeCast(data, &pos); + int len = ((size - pos) >> 1); + msg.WriteString(string(reinterpret_cast(data + pos), len)); + msg.WriteString(string(reinterpret_cast(data + pos + len), size - pos - len)); + msg.WriteBool(fdFlag); + if (fdFlag) { + msg.WriteFileDescriptor(fd); + } + msg.WriteInt32(errCode); + service->CmdRestoreOnFileReady(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool RestoreOnResultReportFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int32_t errCode = TypeCast(data, &pos); + int len = ((size - pos) >> 1); + msg.WriteString(string(reinterpret_cast(data + pos), len)); + msg.WriteString(string(reinterpret_cast(data + pos + len), size - pos - len)); + msg.WriteInt32(errCode); + service->CmdRestoreOnResultReport(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. } - return (ptr[ZERO_NUM] << SHIFT_FIRST) | (ptr[FIRST_NUM] << SHIFT_SECOND) | - (ptr[SECOND_NUM] << SHIFT_THIRD) | (ptr[THIRD_NUM]); + return true; } -bool BackupFuzzTest(const uint8_t *data, size_t size) +bool RestoreOnProcessInfoFuzzTest(sptr service, const uint8_t *data, size_t size) { - /* Validate the length of size */ - if (data == nullptr || size < U32_AT_SIZE) { - return false; + if (data == nullptr) { + return true; } - uint32_t code = ConvertToUint32(data); - if (code > static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_TASK_FINISHED)) { + MessageParcel msg; + MessageParcel reply; + + try { + int len = (size >> 1); + msg.WriteString(string(reinterpret_cast(data), len)); + msg.WriteString(string(reinterpret_cast(data + len), size - len)); + service->CmdRestoreOnProcessInfo(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool IncrementalBackupOnFileReadyFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(bool) + sizeof(int) + sizeof(int) + sizeof(int32_t)) { return true; } - MessageParcel datas; - datas.WriteInterfaceToken(ServiceReverseStub::GetDescriptor()); - datas.WriteBuffer(data, size); - datas.RewindRead(0); + MessageParcel msg; MessageParcel reply; - MessageOption option; - BSessionBackup::Callbacks callbacks; - std::shared_ptr backupPtr = - std::make_shared(callbacks); - backupPtr->OnRemoteRequest(code % MAX_CALL_TRANSACTION, datas, reply, option); + try { + int pos = 0; + int fd = TypeCast(data, &pos); + int manifestFd = TypeCast(data, &pos); + bool fdFlag = TypeCast(data, &pos); + int32_t errCode = TypeCast(data, &pos); + int len = ((size - pos) >> 1); + msg.WriteString(string(reinterpret_cast(data + pos), len)); + msg.WriteString(string(reinterpret_cast(data + pos + len), size - pos - len)); + msg.WriteBool(fdFlag); + if (fdFlag) { + msg.WriteFileDescriptor(fd); + msg.WriteFileDescriptor(manifestFd); + } + msg.WriteInt32(errCode); + service->CmdIncrementalBackupOnFileReady(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } return true; } -bool RestoreFuzzTest(const uint8_t *data, size_t size) +bool IncrementalBackupOnBundleStartedFuzzTest(sptr service, const uint8_t *data, size_t size) { - /* Validate the length of size */ - if (data == nullptr || size < U32_AT_SIZE) { - return false; + if (data == nullptr || size < sizeof(int32_t)) { + return true; } - uint32_t code = ConvertToUint32(data); - if (code < static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_STARTED) || - code > static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_FILE_READY)) { + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int32_t errCode = TypeCast(data, &pos); + msg.WriteInt32(errCode); + msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); + service->CmdIncrementalBackupOnBundleStarted(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool IncrementalBackupOnResultReportFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr) { return true; } - MessageParcel datas; - datas.WriteInterfaceToken(ServiceReverseStub::GetDescriptor()); - datas.WriteBuffer(data, size); - datas.RewindRead(0); + MessageParcel msg; MessageParcel reply; - MessageOption option; - BSessionRestore::Callbacks callbacks; - std::shared_ptr restorePtr = - std::make_shared(callbacks); - restorePtr->OnRemoteRequest(code % MAX_CALL_TRANSACTION, datas, reply, option); + try { + int len = (size >> 1); + msg.WriteString(string(reinterpret_cast(data), len)); + msg.WriteString(string(reinterpret_cast(data + len), size - len)); + service->CmdIncrementalBackupOnResultReport(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } return true; } -bool IncrementalBackupFuzzTest(const uint8_t *data, size_t size) +bool IncrementalBackupOnBundleFinishedFuzzTest(sptr service, const uint8_t *data, size_t size) { - /* Validate the length of size */ - if (data == nullptr || size < U32_AT_SIZE) { - return false; + if (data == nullptr || size < sizeof(int32_t)) { + return true; } - uint32_t code = ConvertToUint32(data); - if (code < static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_FILE_READY) || - code > static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_TASK_FINISHED)) { + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int32_t errCode = TypeCast(data, &pos); + msg.WriteInt32(errCode); + msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); + service->CmdIncrementalBackupOnBundleFinished(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool IncrementalBackupOnAllBundlesFinishedFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { return true; } - MessageParcel datas; - datas.WriteInterfaceToken(ServiceReverseStub::GetDescriptor()); - datas.WriteBuffer(data, size); - datas.RewindRead(0); + MessageParcel msg; MessageParcel reply; - MessageOption option; - BIncrementalBackupSession::Callbacks callbacks; - std::shared_ptr backupPtr = - std::make_shared(callbacks); - backupPtr->OnRemoteRequest(code % MAX_CALL_TRANSACTION, datas, reply, option); + try { + int32_t errCode = TypeCast(data); + msg.WriteInt32(errCode); + service->CmdIncrementalBackupOnAllBundlesFinished(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } return true; } -bool IncrementalRestoreFuzzTest(const uint8_t *data, size_t size) +bool IncrementalBackupOnProcessInfoFuzzTest(sptr service, const uint8_t *data, size_t size) { - /* Validate the length of size */ - if (data == nullptr || size < U32_AT_SIZE) { - return false; + if (data == nullptr) { + return true; } - uint32_t code = ConvertToUint32(data); - if (code < static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_STARTED) || - code > static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_FILE_READY)) { + MessageParcel msg; + MessageParcel reply; + + try { + int len = (size >> 1); + msg.WriteString(string(reinterpret_cast(data), len)); + msg.WriteString(string(reinterpret_cast(data + len), size - len)); + service->CmdIncrementalBackupOnProcessInfo(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool IncrementalBackupOnScanningInfoFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr) { return true; } - MessageParcel datas; - datas.WriteInterfaceToken(ServiceReverseStub::GetDescriptor()); - datas.WriteBuffer(data, size); - datas.RewindRead(0); + MessageParcel msg; MessageParcel reply; - MessageOption option; - BIncrementalRestoreSession::Callbacks callbacks; - std::shared_ptr restorePtr = - std::make_shared(callbacks); - restorePtr->OnRemoteRequest(code % MAX_CALL_TRANSACTION, datas, reply, option); + try { + msg.WriteString(string(reinterpret_cast(data), size)); + service->CmdIncrementalBackupOnScanningInfo(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool IncrementalRestoreOnBundleStartedFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int32_t errCode = TypeCast(data, &pos); + msg.WriteInt32(errCode); + msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); + service->CmdIncrementalRestoreOnBundleStarted(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool IncrementalRestoreOnBundleFinishedFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int32_t errCode = TypeCast(data, &pos); + msg.WriteInt32(errCode); + msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); + service->CmdIncrementalRestoreOnBundleFinished(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool IncrementalRestoreOnAllBundlesFinishedFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int32_t errCode = TypeCast(data); + msg.WriteInt32(errCode); + service->CmdIncrementalRestoreOnAllBundlesFinished(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool IncrementalRestoreOnFileReadyFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(bool) + sizeof(int) + sizeof(int) + sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int fd = TypeCast(data, &pos); + int manifestFd = TypeCast(data, &pos); + bool fdFlag = TypeCast(data, &pos); + int32_t errCode = TypeCast(data, &pos); + int len = ((size - pos) >> 1); + msg.WriteString(string(reinterpret_cast(data + pos), len)); + msg.WriteString(string(reinterpret_cast(data + pos + len), size - pos - len)); + msg.WriteBool(fdFlag); + if (fdFlag) { + msg.WriteFileDescriptor(fd); + msg.WriteFileDescriptor(manifestFd); + } + msg.WriteInt32(errCode); + service->CmdIncrementalRestoreOnFileReady(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool IncrementalRestoreOnResultReportFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(int32_t)) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int pos = 0; + int32_t errCode = TypeCast(data, &pos); + int len = ((size - pos) >> 1); + msg.WriteString(string(reinterpret_cast(data + pos), len)); + msg.WriteString(string(reinterpret_cast(data + pos + len), size - pos - len)); + msg.WriteInt32(errCode); + service->CmdIncrementalRestoreOnResultReport(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } + return true; +} + +bool IncrementalRestoreOnProcessInfoFuzzTest(sptr service, const uint8_t *data, size_t size) +{ + if (data == nullptr) { + return true; + } + + MessageParcel msg; + MessageParcel reply; + + try { + int len = (size >> 1); + msg.WriteString(string(reinterpret_cast(data), len)); + msg.WriteString(string(reinterpret_cast(data + len), size - len)); + service->CmdIncrementalRestoreOnProcessInfo(msg, reply); + } catch (BError &err) { + // Only filter BError errors, Other results are not expected. + } return true; } } // namespace OHOS @@ -163,9 +607,55 @@ bool IncrementalRestoreFuzzTest(const uint8_t *data, size_t size) /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { - OHOS::BackupFuzzTest(data, size); - OHOS::RestoreFuzzTest(data, size); - OHOS::IncrementalBackupFuzzTest(data, size); - OHOS::IncrementalRestoreFuzzTest(data, size); + OHOS::FileManagement::Backup::BSessionBackup::Callbacks backupCallbacks; + OHOS::sptr backupService(new OHOS::FileManagement::Backup::ServiceReverse(backupCallbacks)); + if (backupService == nullptr) { + return 0; + } + OHOS::FileManagement::Backup::BSessionRestore::Callbacks restoreCallbacks; + OHOS::sptr restoreService(new OHOS::FileManagement::Backup::ServiceReverse(restoreCallbacks)); + if (restoreService == nullptr) { + return 0; + } + OHOS::FileManagement::Backup::BIncrementalBackupSession::Callbacks incrementalBackupCallbacks; + OHOS::sptr incrementalBackupService(new OHOS::FileManagement::Backup::ServiceReverse(incrementalBackupCallbacks)); + if (incrementalBackupService == nullptr) { + return 0; + } + OHOS::FileManagement::Backup::BIncrementalRestoreSession::Callbacks incrementalRestoreCallbacks; + OHOS::sptr incrementalRestoreService(new OHOS::FileManagement::Backup::ServiceReverse(incrementalRestoreCallbacks)); + if (incrementalRestoreService == nullptr) { + return 0; + } + + OHOS::BackupOnFileReadyFuzzTest(backupService, data, size); + OHOS::BackupOnBundleStartedFuzzTest(backupService, data, size); + OHOS::BackupOnResultReportFuzzTest(backupService, data, size); + OHOS::BackupOnBundleFinishedFuzzTest(backupService, data, size); + OHOS::BackupOnAllBundlesFinishedFuzzTest(backupService, data, size); + OHOS::BackupOnProcessInfoFuzzTest(backupService, data, size); + OHOS::BackupOnScanningInfoFuzzTest(backupService, data, size); + + OHOS::RestoreOnBundleStartedFuzzTest(restoreService, data, size); + OHOS::RestoreOnBundleFinishedFuzzTest(restoreService, data, size); + OHOS::RestoreOnAllBundlesFinishedFuzzTest(restoreService, data, size); + OHOS::RestoreOnFileReadyFuzzTest(restoreService, data, size); + OHOS::RestoreOnResultReportFuzzTest(restoreService, data, size); + OHOS::RestoreOnProcessInfoFuzzTest(restoreService, data, size); + + OHOS::IncrementalBackupOnFileReadyFuzzTest(incrementalBackupService, data, size); + OHOS::IncrementalBackupOnBundleStartedFuzzTest(incrementalBackupService, data, size); + OHOS::IncrementalBackupOnResultReportFuzzTest(incrementalBackupService, data, size); + OHOS::IncrementalBackupOnBundleFinishedFuzzTest(incrementalBackupService, data, size); + OHOS::IncrementalBackupOnAllBundlesFinishedFuzzTest(incrementalBackupService, data, size); + OHOS::IncrementalBackupOnProcessInfoFuzzTest(incrementalBackupService, data, size); + OHOS::IncrementalBackupOnScanningInfoFuzzTest(incrementalBackupService, data, size); + + OHOS::IncrementalRestoreOnBundleStartedFuzzTest(incrementalRestoreService, data, size); + OHOS::IncrementalRestoreOnBundleFinishedFuzzTest(incrementalRestoreService, data, size); + OHOS::IncrementalRestoreOnAllBundlesFinishedFuzzTest(incrementalRestoreService, data, size); + OHOS::IncrementalRestoreOnFileReadyFuzzTest(incrementalRestoreService, data, size); + OHOS::IncrementalRestoreOnResultReportFuzzTest(incrementalRestoreService, data, size); + OHOS::IncrementalRestoreOnProcessInfoFuzzTest(incrementalRestoreService, data, size); return 0; } \ No newline at end of file diff --git a/test/unittest/resource/bundle_dependencies/fileShareA/BUILD.gn b/test/unittest/resource/bundle_dependencies/fileShareA/BUILD.gn index 742f27f3b..0d98ff331 100644 --- a/test/unittest/resource/bundle_dependencies/fileShareA/BUILD.gn +++ b/test/unittest/resource/bundle_dependencies/fileShareA/BUILD.gn @@ -18,7 +18,7 @@ ohos_hap("filesharea") { hap_name = "filesharea" subsystem_name = "filemanagement" part_name = "app_file_service" - final_hap_path = "$root_out_dir/tests/unittest/filemanagement/app_file_service/resource/${hap_name}.hap" + final_hap_path = "$root_out_dir/tests/unittest/app_file_service/app_file_service/file_share/resource/${hap_name}.hap" testonly = true deps = [ ":fileShareA_ets_assets", @@ -40,4 +40,4 @@ ohos_resources("fileShareA_ets_resources") { sources = [ "entry/src/main/resources" ] deps = [ ":fileShareA_app_profile" ] hap_profile = "entry/src/main/module.json" -} \ No newline at end of file +} diff --git a/test/unittest/resource/bundle_dependencies/fileShareB/BUILD.gn b/test/unittest/resource/bundle_dependencies/fileShareB/BUILD.gn index 7109a036f..9361510a8 100644 --- a/test/unittest/resource/bundle_dependencies/fileShareB/BUILD.gn +++ b/test/unittest/resource/bundle_dependencies/fileShareB/BUILD.gn @@ -18,7 +18,7 @@ ohos_hap("fileshareb") { hap_name = "fileshareb" subsystem_name = "filemanagement" part_name = "app_file_service" - final_hap_path = "$root_out_dir/tests/unittest/filemanagement/app_file_service/resource/${hap_name}.hap" + final_hap_path = "$root_out_dir/tests/unittest/app_file_service/app_file_service/file_share/resource/${hap_name}.hap" testonly = true deps = [ ":fileShareB_ets_assets", @@ -40,4 +40,4 @@ ohos_resources("fileShareB_ets_resources") { sources = [ "entry/src/main/resources" ] deps = [ ":fileShareB_app_profile" ] hap_profile = "entry/src/main/module.json" -} \ No newline at end of file +} -- Gitee