src/elf/elf_factory.cpp

/*
 * 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 "elf_factory.h"

#include <string>
#include <algorithm>
#include <cstdlib>
#include <fcntl.h>
#include <unistd.h>
#include <utility>
#include <sys/stat.h>
#include <sys/types.h>

#include "dfx_define.h"
#include "dfx_log.h"
#include "dfx_maps.h"
#include "dfx_trace_dlsym.h"
#include "dfx_util.h"
#include "smart_fd.h"
#if defined(ENABLE_MINIDEBUGINFO)
#include "7zCrc.h"
#include "unwinder_config.h"
#include "Xz.h"
#include "XzCrc64.h"
#endif

namespace OHOS {
namespace HiviewDFX {
namespace {
#undef LOG_DOMAIN
#undef LOG_TAG
#define LOG_DOMAIN 0xD002D11
#define LOG_TAG "ElfFactory"
}
#if defined(ENABLE_MINIDEBUGINFO)
std::shared_ptr<DfxElf> MiniDebugInfoFactory::Create()
{
    DFX_TRACE_SCOPED_DLSYM("CreateMiniDebugInfo");
    if (!UnwinderConfig::GetEnableMiniDebugInfo()) {
        return nullptr;
    }

    std::vector<uint8_t> miniDebugInfoData;
    if (!XzDecompress(reinterpret_cast<uint8_t *>(gnuDebugDataHdr_.address),
        gnuDebugDataHdr_.size, miniDebugInfoData)) {
        DFXLOGU("Failed to decompressed .gnu_debugdata seciton.");
        return nullptr;
    }
    // miniDebugInfoData store the decompressed bytes.
    // use these bytes to construct an elf.
    auto mMap = std::make_shared<DfxMmap>();
    if (!mMap->Init(std::move(miniDebugInfoData))) {
        DFXLOGE("Failed to init mmap_!");
        return nullptr;
    }
    auto miniDebugInfo = std::make_shared<DfxElf>(mMap);
    if (!miniDebugInfo->IsValid()) {
        DFXLOGE("Failed to parse mini debuginfo Elf.");
        return nullptr;
    }
    return miniDebugInfo;
}

static void* XzAlloc(ISzAllocPtr, size_t size)
{
    return malloc(size);
}

static void XzFree(ISzAllocPtr, void *address)
{
    free(address);
}

bool MiniDebugInfoFactory::XzDecompress(const uint8_t *src, size_t srcLen, std::vector<uint8_t>& out)
{
    DFX_TRACE_SCOPED_DLSYM("XzDecompress");
    ISzAlloc alloc;
    CXzUnpacker state;
    alloc.Alloc = XzAlloc;
    alloc.Free = XzFree;
    XzUnpacker_Construct(&state, &alloc);
    CrcGenerateTable();
    Crc64GenerateTable();
    size_t srcOff = 0;
    size_t dstOff = 0;
    out.resize(srcLen);
    ECoderStatus status = CODER_STATUS_NOT_FINISHED;
    constexpr uint16_t expandFactor = 2;
    while (status == CODER_STATUS_NOT_FINISHED) {
        out.resize(out.size() * expandFactor);
        size_t srcRemain = srcLen - srcOff;
        size_t dstRemain = out.size() - dstOff;
        int res = XzUnpacker_Code(&state,
                                  reinterpret_cast<Byte*>(&out[dstOff]), &dstRemain,
                                  reinterpret_cast<const Byte*>(&src[srcOff]), &srcRemain,
                                  true, CODER_FINISH_ANY, &status);
        if (res != SZ_OK) {
            XzUnpacker_Free(&state);
            return false;
        }
        srcOff += srcRemain;
        dstOff += dstRemain;
    }
    XzUnpacker_Free(&state);
    if (!XzUnpacker_IsStreamWasFinished(&state)) {
        return false;
    }
    out.resize(dstOff);
    return true;
}
#endif

std::shared_ptr<DfxElf> RegularElfFactory::Create()
{
    std::shared_ptr<DfxElf> regularElf = std::make_shared<DfxElf>();
    if (filePath_.empty()) {
        DFXLOGE("file path is empty!");
        return regularElf;
    }
    DFXLOGU("file: %{public}s", filePath_.c_str());
#if defined(is_ohos) && is_ohos
    if (!DfxMaps::IsLegalMapItem(filePath_)) {
        DFXLOGD("Illegal map file, please check file: %{public}s", filePath_.c_str());
        return regularElf;
    }
#endif

#if defined(is_mingw) && is_mingw
    int fd = OHOS_TEMP_FAILURE_RETRY(open(filePath_.c_str(), O_RDONLY | O_BINARY));
#else
    int fd = OHOS_TEMP_FAILURE_RETRY(open(filePath_.c_str(), O_RDONLY));
#endif
    SmartFd smartFd(fd);
    if (!smartFd) {
        DFXLOGE("Failed to open file: %{public}s, errno(%{public}d)", filePath_.c_str(), errno);
        return regularElf;
    }
    auto mMap = std::make_shared<DfxMmap>();
    if (!mMap->Init(smartFd.GetFd(), static_cast<size_t>(GetFileSize(smartFd.GetFd())), 0)) {
        DFXLOGE("Failed to mmap init.");
        return regularElf;
    }
    regularElf->SetMmap(mMap);
    return regularElf;
}

std::shared_ptr<DfxElf> VdsoElfFactory::Create()
{
#if is_ohos && !is_mingw
    std::vector<uint8_t> shmmData(size_);
    size_t byte = ReadProcMemByPid(pid_, begin_, shmmData.data(), size_);
    if (byte != size_) {
        DFXLOGE("Failed to read shmm data");
        return nullptr;
    }

    auto mMap = std::make_shared<DfxMmap>();
    if (!mMap->Init(std::move(shmmData))) {
        DFXLOGE("Failed to init mmap_!");
        return nullptr;
    }
    auto vdsoElf = std::make_shared<DfxElf>(mMap);
    if (!vdsoElf->IsValid()) {
        DFXLOGE("Failed to parse Embedded Elf.");
        return nullptr;
    }
    return vdsoElf;
#endif
    return nullptr;
}


std::shared_ptr<DfxElf> CompressHapElfFactory::Create()
{
    /*
      elf header is in the first mmap area
      c3840000-c38a6000 r--p 00174000 /data/storage/el1/bundle/entry.hap <- program header
      c38a6000-c3945000 r-xp 001d9000 /data/storage/el1/bundle/entry.hap <- pc is in this region
      c3945000-c394b000 r--p 00277000 /data/storage/el1/bundle/entry.hap
      c394b000-c394c000 rw-p 0027c000 /data/storage/el1/bundle/entry.hap
    */
    if (prevMap_ == nullptr) {
        DFXLOGE("current hap map item or prev map item , maybe pc is wrong?");
        return nullptr;
    }
    // Do not use the Realpath function, the sandbox path Realpath function will return failure
    if (!StartsWith(filePath_, "/proc") || !EndsWith(filePath_, ".hap")) {
        DFXLOGD("Illegal file path, please check file: %{public}s", filePath_.c_str());
        return nullptr;
    }
    SmartFd smartFd(static_cast<int>(OHOS_TEMP_FAILURE_RETRY(open(filePath_.c_str(), O_RDONLY))));
    if (!smartFd) {
        DFXLOGE("Failed to open hap file, errno(%{public}d)", errno);
        return nullptr;
    }

    size_t elfSize = 0;
    if (!VerifyElf(smartFd.GetFd(), elfSize)) {
        return {};
    }
    DFXLOGU("elfSize: %{public}zu", elfSize);
    auto mMap = std::make_shared<DfxMmap>();
    if (!mMap->Init(smartFd.GetFd(), elfSize, prevMap_->offset)) {
        DFXLOGE("Failed to init mmap_!");
        return {};
    }
    std::shared_ptr<DfxElf> compressHapElf = std::make_shared<DfxElf>(mMap);
    compressHapElf->SetBaseOffset(prevMap_->offset);
    if (!compressHapElf->IsValid()) {
        DFXLOGE("Failed to parse compress hap Elf.");
        return {};
    }
    return compressHapElf;
}

bool CompressHapElfFactory::VerifyElf(int fd, size_t& elfSize)
{
    size_t size = prevMap_->end - prevMap_->begin;
    auto mmap = std::make_shared<DfxMmap>();
    if (!mmap->Init(fd, size, static_cast<off_t>(prevMap_->offset))) {
        DFXLOGE("Failed to mmap program header in hap.");
        return false;
    }
    const uint8_t* data = static_cast<const uint8_t*>(mmap->Get());
    if (data == nullptr || memcmp(data, ELFMAG, SELFMAG) != 0) {
        DFXLOGE("Invalid elf hdr?");
        return false;
    }
    uint8_t classType = data[EI_CLASS];
    elfSize = 0;
    if (classType == ELFCLASS32) {
        const Elf32_Ehdr* ehdr = reinterpret_cast<const Elf32_Ehdr *>(data);
        elfSize = static_cast<size_t>(ehdr->e_shoff + (ehdr->e_shentsize * ehdr->e_shnum));
    } else if (classType == ELFCLASS64) {
        const Elf64_Ehdr* ehdr = reinterpret_cast<const Elf64_Ehdr *>(data);
        elfSize = static_cast<size_t>(ehdr->e_shoff + (ehdr->e_shentsize * ehdr->e_shnum));
    }
    if (elfSize == 0) {
        DFXLOGE("elf size equal zero, invalid elf!");
        return false;
    }
    auto fileSize = GetFileSize(fd);
    if (fileSize <= 0) {
        DFXLOGE("file size can not less or equal zero!");
        return false;
    }
    if (elfSize + prevMap_->offset > static_cast<size_t>(fileSize)) {
        DFXLOGE("Invalid elf size? elf size: %{public}zu, hap size: %{public}zu", elfSize,
            static_cast<size_t>(fileSize));
        return false;
    }
    return true;
}
} // namespace HiviewDFX
} // namespace OHOS