/* $Id$ */ /** @file * IPRT - Binary Image Loader, Extended Features. */ /* * Copyright (C) 2006-2023 Oracle and/or its affiliates. * * This file is part of VirtualBox base platform packages, as * available from https://www.virtualbox.org. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation, in version 3 of the * License. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see . * * The contents of this file may alternatively be used under the terms * of the Common Development and Distribution License Version 1.0 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included * in the VirtualBox distribution, in which case the provisions of the * CDDL are applicable instead of those of the GPL. * * You may elect to license modified versions of this file under the * terms and conditions of either the GPL or the CDDL or both. * * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 */ /********************************************************************************************************************************* * Header Files * *********************************************************************************************************************************/ #define LOG_GROUP RTLOGGROUP_LDR #include #include "internal/iprt.h" #include #include #include #include #include #include #include #include #include #include #include "internal/ldr.h" #if defined(LDR_ONLY_PE) || defined(LDR_ONLY_MACHO) # undef LDR_WITH_PE # undef LDR_WITH_ELF # undef LDR_WITH_LX # undef LDR_WITH_LE # undef LDR_WITH_MACHO # undef LDR_WITH_NE # undef LDR_WITH_MZ # undef LDR_WITH_AOUT # ifdef LDR_ONLY_PE # define LDR_WITH_PE # endif # ifdef LDR_ONLY_MACHO # define LDR_WITH_MACHO # endif #endif RTDECL(int) RTLdrOpenWithReader(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phMod, PRTERRINFO pErrInfo) { /* * Resolve RTLDRARCH_HOST. */ if (enmArch == RTLDRARCH_HOST) enmArch = RTLdrGetHostArch(); /* * Read and verify the file signature. */ union { char ach[4]; uint16_t au16[2]; uint32_t u32; } uSign; int rc = pReader->pfnRead(pReader, &uSign, sizeof(uSign), 0); if (RT_FAILURE(rc)) return rc; if ( uSign.au16[0] != IMAGE_DOS_SIGNATURE && uSign.u32 != IMAGE_NT_SIGNATURE && uSign.u32 != IMAGE_ELF_SIGNATURE && uSign.au16[0] != IMAGE_LX_SIGNATURE && uSign.u32 != IMAGE_MACHO64_SIGNATURE && uSign.u32 != IMAGE_MACHO64_SIGNATURE_OE && uSign.u32 != IMAGE_MACHO32_SIGNATURE && uSign.u32 != IMAGE_MACHO32_SIGNATURE_OE && uSign.u32 != IMAGE_FAT_SIGNATURE && uSign.u32 != IMAGE_FAT_SIGNATURE_OE ) { Log(("rtldrOpenWithReader: %s: unknown magic %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0])); return VERR_INVALID_EXE_SIGNATURE; } uint32_t offHdr = 0; if (uSign.au16[0] == IMAGE_DOS_SIGNATURE) { rc = pReader->pfnRead(pReader, &offHdr, sizeof(offHdr), RT_UOFFSETOF(IMAGE_DOS_HEADER, e_lfanew)); if (RT_FAILURE(rc)) return rc; if (offHdr <= sizeof(IMAGE_DOS_HEADER)) { Log(("rtldrOpenWithReader: %s: no new header / invalid offset %#RX32\n", pReader->pfnLogName(pReader), offHdr)); return VERR_INVALID_EXE_SIGNATURE; } rc = pReader->pfnRead(pReader, &uSign, sizeof(uSign), offHdr); if (RT_FAILURE(rc)) return rc; if ( uSign.u32 != IMAGE_NT_SIGNATURE && uSign.au16[0] != IMAGE_LX_SIGNATURE && uSign.au16[0] != IMAGE_LE_SIGNATURE && uSign.au16[0] != IMAGE_NE_SIGNATURE) { Log(("rtldrOpenWithReader: %s: unknown new magic %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0])); return VERR_INVALID_EXE_SIGNATURE; } } /* * Create image interpreter instance depending on the signature. */ if (uSign.u32 == IMAGE_NT_SIGNATURE) #ifdef LDR_WITH_PE rc = rtldrPEOpen(pReader, fFlags, enmArch, offHdr, phMod, pErrInfo); #else rc = VERR_PE_EXE_NOT_SUPPORTED; #endif else if (uSign.u32 == IMAGE_ELF_SIGNATURE) #if defined(LDR_WITH_ELF) rc = rtldrELFOpen(pReader, fFlags, enmArch, phMod, pErrInfo); #else rc = VERR_ELF_EXE_NOT_SUPPORTED; #endif else if ( uSign.u32 == IMAGE_MACHO64_SIGNATURE || uSign.u32 == IMAGE_MACHO64_SIGNATURE_OE || uSign.u32 == IMAGE_MACHO32_SIGNATURE || uSign.u32 == IMAGE_MACHO32_SIGNATURE_OE) #if defined(LDR_WITH_MACHO) rc = rtldrMachOOpen(pReader, fFlags, enmArch, offHdr, phMod, pErrInfo); #else rc = VERR_INVALID_EXE_SIGNATURE; #endif else if ( uSign.u32 == IMAGE_FAT_SIGNATURE || uSign.u32 == IMAGE_FAT_SIGNATURE_OE) #if defined(LDR_WITH_MACHO) rc = rtldrFatOpen(pReader, fFlags, enmArch, phMod, pErrInfo); #else rc = VERR_INVALID_EXE_SIGNATURE; #endif else if (uSign.au16[0] == IMAGE_LX_SIGNATURE) #ifdef LDR_WITH_LX rc = rtldrLXOpen(pReader, fFlags, enmArch, offHdr, phMod, pErrInfo); #else rc = VERR_LX_EXE_NOT_SUPPORTED; #endif else if (uSign.au16[0] == IMAGE_LE_SIGNATURE) #ifdef LDR_WITH_LE rc = rtldrLEOpen(pReader, fFlags, enmArch, phMod, pErrInfo); #else rc = VERR_LE_EXE_NOT_SUPPORTED; #endif else if (uSign.au16[0] == IMAGE_NE_SIGNATURE) #ifdef LDR_WITH_NE rc = rtldrNEOpen(pReader, fFlags, enmArch, phMod, pErrInfo); #else rc = VERR_NE_EXE_NOT_SUPPORTED; #endif else if (uSign.au16[0] == IMAGE_DOS_SIGNATURE) #ifdef LDR_WITH_MZ rc = rtldrMZOpen(pReader, fFlags, enmArch, phMod, pErrInfo); #else rc = VERR_MZ_EXE_NOT_SUPPORTED; #endif else if (/* uSign.u32 == IMAGE_AOUT_A_SIGNATURE || uSign.u32 == IMAGE_AOUT_Z_SIGNATURE*/ /** @todo find the aout magics in emx or binutils. */ 0) #ifdef LDR_WITH_AOUT rc = rtldrAOUTOpen(pReader, fFlags, enmArch, phMod, pErrInfo); #else rc = VERR_AOUT_EXE_NOT_SUPPORTED; #endif else { Log(("rtldrOpenWithReader: %s: the format isn't implemented %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0])); rc = VERR_INVALID_EXE_SIGNATURE; } LogFlow(("rtldrOpenWithReader: %s: returns %Rrc *phMod=%p\n", pReader->pfnLogName(pReader), rc, *phMod)); return rc; } RTDECL(size_t) RTLdrSize(RTLDRMOD hLdrMod) { LogFlow(("RTLdrSize: hLdrMod=%RTldrm\n", hLdrMod)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), ~(size_t)0); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), ~(size_t)0); /* * Do it. */ size_t cb = pMod->pOps->pfnGetImageSize(pMod); LogFlow(("RTLdrSize: returns %zu\n", cb)); return cb; } RT_EXPORT_SYMBOL(RTLdrSize); RTDECL(int) RTLdrGetBits(RTLDRMOD hLdrMod, void *pvBits, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser) { LogFlow(("RTLdrGetBits: hLdrMod=%RTldrm pvBits=%p BaseAddress=%RTptr pfnGetImport=%p pvUser=%p\n", hLdrMod, pvBits, BaseAddress, pfnGetImport, pvUser)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrReturn(pvBits, VERR_INVALID_POINTER); AssertPtrNullReturn(pfnGetImport, VERR_INVALID_POINTER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER); /* * Do it. */ int rc = pMod->pOps->pfnGetBits(pMod, pvBits, BaseAddress, pfnGetImport, pvUser); LogFlow(("RTLdrGetBits: returns %Rrc\n",rc)); return rc; } RT_EXPORT_SYMBOL(RTLdrGetBits); RTDECL(int) RTLdrRelocate(RTLDRMOD hLdrMod, void *pvBits, RTLDRADDR NewBaseAddress, RTLDRADDR OldBaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser) { LogFlow(("RTLdrRelocate: hLdrMod=%RTldrm pvBits=%p NewBaseAddress=%RTptr OldBaseAddress=%RTptr pfnGetImport=%p pvUser=%p\n", hLdrMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrReturn(pvBits, VERR_INVALID_POINTER); AssertPtrReturn(pfnGetImport, VERR_INVALID_POINTER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER); /* * Do it. */ int rc = pMod->pOps->pfnRelocate(pMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser); LogFlow(("RTLdrRelocate: returns %Rrc\n", rc)); return rc; } RT_EXPORT_SYMBOL(RTLdrRelocate); RTDECL(int) RTLdrGetSymbolEx(RTLDRMOD hLdrMod, const void *pvBits, RTLDRADDR BaseAddress, uint32_t iOrdinal, const char *pszSymbol, PRTLDRADDR pValue) { LogFlow(("RTLdrGetSymbolEx: hLdrMod=%RTldrm pvBits=%p BaseAddress=%RTptr iOrdinal=%#x pszSymbol=%p:{%s} pValue=%p\n", hLdrMod, pvBits, BaseAddress, iOrdinal, pszSymbol, pszSymbol, pValue)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrNullReturn(pvBits, VERR_INVALID_POINTER); AssertPtrNullReturn(pszSymbol, VERR_INVALID_POINTER); AssertReturn(pszSymbol || iOrdinal != UINT32_MAX, VERR_INVALID_PARAMETER); AssertPtrReturn(pValue, VERR_INVALID_POINTER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; /* * Do it. */ int rc; if (pMod->pOps->pfnGetSymbolEx) rc = pMod->pOps->pfnGetSymbolEx(pMod, pvBits, BaseAddress, iOrdinal, pszSymbol, pValue); else if (!BaseAddress && !pvBits && iOrdinal == UINT32_MAX) { void *pvValue; rc = pMod->pOps->pfnGetSymbol(pMod, pszSymbol, &pvValue); if (RT_SUCCESS(rc)) *pValue = (uintptr_t)pvValue; } else AssertMsgFailedReturn(("BaseAddress=%RTptr pvBits=%p\n", BaseAddress, pvBits), VERR_INVALID_FUNCTION); LogFlow(("RTLdrGetSymbolEx: returns %Rrc *pValue=%p\n", rc, *pValue)); return rc; } RT_EXPORT_SYMBOL(RTLdrGetSymbolEx); RTDECL(int) RTLdrQueryForwarderInfo(RTLDRMOD hLdrMod, const void *pvBits, uint32_t iOrdinal, const char *pszSymbol, PRTLDRIMPORTINFO pInfo, size_t cbInfo) { LogFlow(("RTLdrQueryForwarderInfo: hLdrMod=%RTldrm pvBits=%p iOrdinal=%#x pszSymbol=%p:{%s} pInfo=%p cbInfo=%zu\n", hLdrMod, pvBits, iOrdinal, pszSymbol, pszSymbol, pInfo, cbInfo)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrNullReturn(pvBits, VERR_INVALID_POINTER); AssertMsgReturn(pszSymbol, ("pszSymbol=%p\n", pszSymbol), VERR_INVALID_PARAMETER); AssertPtrReturn(pInfo, VERR_INVALID_PARAMETER); AssertReturn(cbInfo >= sizeof(*pInfo), VERR_INVALID_PARAMETER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; /* * Do it. */ int rc; if (pMod->pOps->pfnQueryForwarderInfo) { rc = pMod->pOps->pfnQueryForwarderInfo(pMod, pvBits, iOrdinal, pszSymbol, pInfo, cbInfo); if (RT_SUCCESS(rc)) LogFlow(("RTLdrQueryForwarderInfo: returns %Rrc pInfo={%#x,%#x,%s,%s}\n", rc, pInfo->iSelfOrdinal, pInfo->iOrdinal, pInfo->pszSymbol, pInfo->szModule)); else LogFlow(("RTLdrQueryForwarderInfo: returns %Rrc\n", rc)); } else { LogFlow(("RTLdrQueryForwarderInfo: returns VERR_NOT_SUPPORTED\n")); rc = VERR_NOT_SUPPORTED; } return rc; } RT_EXPORT_SYMBOL(RTLdrQueryForwarderInfo); RTDECL(int) RTLdrEnumSymbols(RTLDRMOD hLdrMod, unsigned fFlags, const void *pvBits, RTLDRADDR BaseAddress, PFNRTLDRENUMSYMS pfnCallback, void *pvUser) { LogFlow(("RTLdrEnumSymbols: hLdrMod=%RTldrm fFlags=%#x pvBits=%p BaseAddress=%RTptr pfnCallback=%p pvUser=%p\n", hLdrMod, fFlags, pvBits, BaseAddress, pfnCallback, pvUser)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrNullReturn(pvBits, VERR_INVALID_POINTER); AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; //AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER); /* * Do it. */ int rc = pMod->pOps->pfnEnumSymbols(pMod, fFlags, pvBits, BaseAddress, pfnCallback, pvUser); LogFlow(("RTLdrEnumSymbols: returns %Rrc\n", rc)); return rc; } RT_EXPORT_SYMBOL(RTLdrEnumSymbols); RTDECL(int) RTLdrEnumDbgInfo(RTLDRMOD hLdrMod, const void *pvBits, PFNRTLDRENUMDBG pfnCallback, void *pvUser) { LogFlow(("RTLdrEnumDbgInfo: hLdrMod=%RTldrm pvBits=%p pfnCallback=%p pvUser=%p\n", hLdrMod, pvBits, pfnCallback, pvUser)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrNullReturn(pvBits, VERR_INVALID_POINTER); AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; //AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER); /* * Do it. */ int rc; if (pMod->pOps->pfnEnumDbgInfo) rc = pMod->pOps->pfnEnumDbgInfo(pMod, pvBits, pfnCallback, pvUser); else rc = VERR_NOT_SUPPORTED; LogFlow(("RTLdrEnumDbgInfo: returns %Rrc\n", rc)); return rc; } RT_EXPORT_SYMBOL(RTLdrEnumDbgInfo); RTDECL(int) RTLdrEnumSegments(RTLDRMOD hLdrMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser) { LogFlow(("RTLdrEnumSegments: hLdrMod=%RTldrm pfnCallback=%p pvUser=%p\n", hLdrMod, pfnCallback, pvUser)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; //AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER); /* * Do it. */ int rc; if (pMod->pOps->pfnEnumSegments) rc = pMod->pOps->pfnEnumSegments(pMod, pfnCallback, pvUser); else rc = VERR_NOT_SUPPORTED; LogFlow(("RTLdrEnumSegments: returns %Rrc\n", rc)); return rc; } RT_EXPORT_SYMBOL(RTLdrEnumSegments); RTDECL(int) RTLdrLinkAddressToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR LinkAddress, uint32_t *piSeg, PRTLDRADDR poffSeg) { LogFlow(("RTLdrLinkAddressToSegOffset: hLdrMod=%RTldrm LinkAddress=%RTptr piSeg=%p poffSeg=%p\n", hLdrMod, LinkAddress, piSeg, poffSeg)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrReturn(piSeg, VERR_INVALID_POINTER); AssertPtrReturn(poffSeg, VERR_INVALID_POINTER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; //AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER); *piSeg = UINT32_MAX; *poffSeg = ~(RTLDRADDR)0; /* * Do it. */ int rc; if (pMod->pOps->pfnLinkAddressToSegOffset) rc = pMod->pOps->pfnLinkAddressToSegOffset(pMod, LinkAddress, piSeg, poffSeg); else rc = VERR_NOT_SUPPORTED; LogFlow(("RTLdrLinkAddressToSegOffset: returns %Rrc %#x:%RTptr\n", rc, *piSeg, *poffSeg)); return rc; } RT_EXPORT_SYMBOL(RTLdrLinkAddressToSegOffset); RTDECL(int) RTLdrLinkAddressToRva(RTLDRMOD hLdrMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva) { LogFlow(("RTLdrLinkAddressToRva: hLdrMod=%RTldrm LinkAddress=%RTptr pRva=%p\n", hLdrMod, LinkAddress, pRva)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrReturn(pRva, VERR_INVALID_POINTER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; //AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER); *pRva = ~(RTLDRADDR)0; /* * Do it. */ int rc; if (pMod->pOps->pfnLinkAddressToRva) rc = pMod->pOps->pfnLinkAddressToRva(pMod, LinkAddress, pRva); else rc = VERR_NOT_SUPPORTED; LogFlow(("RTLdrLinkAddressToRva: returns %Rrc %RTptr\n", rc, *pRva)); return rc; } RT_EXPORT_SYMBOL(RTLdrLinkAddressToRva); RTDECL(int) RTLdrSegOffsetToRva(RTLDRMOD hLdrMod, uint32_t iSeg, RTLDRADDR offSeg, PRTLDRADDR pRva) { LogFlow(("RTLdrSegOffsetToRva: hLdrMod=%RTldrm iSeg=%#x offSeg=%RTptr pRva=%p\n", hLdrMod, iSeg, offSeg, pRva)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrReturn(pRva, VERR_INVALID_POINTER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; //AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER); *pRva = ~(RTLDRADDR)0; /* * Do it. */ int rc; if (pMod->pOps->pfnSegOffsetToRva) rc = pMod->pOps->pfnSegOffsetToRva(pMod, iSeg, offSeg, pRva); else rc = VERR_NOT_SUPPORTED; LogFlow(("RTLdrSegOffsetToRva: returns %Rrc %RTptr\n", rc, *pRva)); return rc; } RT_EXPORT_SYMBOL(RTLdrSegOffsetToRva); RTDECL(int) RTLdrRvaToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR Rva, uint32_t *piSeg, PRTLDRADDR poffSeg) { LogFlow(("RTLdrRvaToSegOffset: hLdrMod=%RTldrm Rva=%RTptr piSeg=%p poffSeg=%p\n", hLdrMod, Rva, piSeg, poffSeg)); /* * Validate input. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); AssertPtrReturn(piSeg, VERR_INVALID_POINTER); AssertPtrReturn(poffSeg, VERR_INVALID_POINTER); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; //AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER); *piSeg = UINT32_MAX; *poffSeg = ~(RTLDRADDR)0; /* * Do it. */ int rc; if (pMod->pOps->pfnRvaToSegOffset) rc = pMod->pOps->pfnRvaToSegOffset(pMod, Rva, piSeg, poffSeg); else rc = VERR_NOT_SUPPORTED; LogFlow(("RTLdrRvaToSegOffset: returns %Rrc %#x:%RTptr\n", rc, *piSeg, *poffSeg)); return rc; } RT_EXPORT_SYMBOL(RTLdrRvaToSegOffset); RTDECL(int) RTLdrQueryProp(RTLDRMOD hLdrMod, RTLDRPROP enmProp, void *pvBuf, size_t cbBuf) { return RTLdrQueryPropEx(hLdrMod, enmProp, NULL /*pvBits*/, pvBuf, cbBuf, NULL); } RT_EXPORT_SYMBOL(RTLdrQueryProp); RTDECL(int) RTLdrQueryPropEx(RTLDRMOD hLdrMod, RTLDRPROP enmProp, void *pvBits, void *pvBuf, size_t cbBuf, size_t *pcbRet) { AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), RTLDRENDIAN_INVALID); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; AssertPtrNullReturn(pcbRet, VERR_INVALID_POINTER); size_t cbRet; if (!pcbRet) pcbRet = &cbRet; /* * Do some pre screening of the input */ switch (enmProp) { case RTLDRPROP_UUID: *pcbRet = sizeof(RTUUID); AssertReturn(cbBuf == sizeof(RTUUID), VERR_INVALID_PARAMETER); break; case RTLDRPROP_TIMESTAMP_SECONDS: *pcbRet = sizeof(int64_t); AssertReturn(cbBuf == sizeof(int32_t) || cbBuf == sizeof(int64_t), VERR_INVALID_PARAMETER); *pcbRet = cbBuf; break; case RTLDRPROP_IS_SIGNED: *pcbRet = sizeof(bool); AssertReturn(cbBuf == sizeof(bool), VERR_INVALID_PARAMETER); break; case RTLDRPROP_PKCS7_SIGNED_DATA: case RTLDRPROP_SHA1_PAGE_HASHES: case RTLDRPROP_SHA256_PAGE_HASHES: *pcbRet = 0; break; case RTLDRPROP_HASHABLE_PAGES: *pcbRet = sizeof(uint32_t); AssertReturn(cbBuf >= sizeof(uint32_t), VERR_INVALID_PARAMETER); break; case RTLDRPROP_SIGNATURE_CHECKS_ENFORCED: *pcbRet = sizeof(bool); AssertReturn(cbBuf == sizeof(bool), VERR_INVALID_PARAMETER); break; case RTLDRPROP_IMPORT_COUNT: *pcbRet = sizeof(uint32_t); AssertReturn(cbBuf == sizeof(uint32_t), VERR_INVALID_PARAMETER); break; case RTLDRPROP_IMPORT_MODULE: *pcbRet = sizeof(uint32_t); AssertReturn(cbBuf >= sizeof(uint32_t), VERR_INVALID_PARAMETER); break; case RTLDRPROP_FILE_OFF_HEADER: *pcbRet = sizeof(uint64_t); AssertReturn(cbBuf == sizeof(uint32_t) || cbBuf == sizeof(uint64_t), VERR_INVALID_PARAMETER); break; case RTLDRPROP_INTERNAL_NAME: case RTLDRPROP_UNWIND_TABLE: *pcbRet = 0; break; case RTLDRPROP_UNWIND_INFO: AssertReturn(pvBuf, VERR_INVALID_POINTER); AssertReturn(cbBuf >= sizeof(uint32_t), VERR_INVALID_PARAMETER); *pcbRet = 0; break; case RTLDRPROP_BUILDID: *pcbRet = 0; break; default: AssertFailedReturn(VERR_INVALID_FUNCTION); } AssertPtrReturn(pvBuf, VERR_INVALID_POINTER); /* * Call the image specific worker, if there is one. */ if (!pMod->pOps->pfnQueryProp) return VERR_NOT_SUPPORTED; return pMod->pOps->pfnQueryProp(pMod, enmProp, pvBits, pvBuf, cbBuf, pcbRet); } RT_EXPORT_SYMBOL(RTLdrQueryPropEx); RTDECL(int) RTLdrVerifySignature(RTLDRMOD hLdrMod, PFNRTLDRVALIDATESIGNEDDATA pfnCallback, void *pvUser, PRTERRINFO pErrInfo) { AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER); /* * Call the image specific worker, if there is one. */ if (!pMod->pOps->pfnVerifySignature) return VERR_NOT_SUPPORTED; return pMod->pOps->pfnVerifySignature(pMod, pfnCallback, pvUser, pErrInfo); } RT_EXPORT_SYMBOL(RTLdrVerifySignature); RTDECL(int) RTLdrHashImage(RTLDRMOD hLdrMod, RTDIGESTTYPE enmDigest, uint8_t *pabHash, size_t cbHash) { AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; /* * Make sure there is sufficient space for the wanted digest and that * it's supported. */ switch (enmDigest) { case RTDIGESTTYPE_MD5: AssertReturn(cbHash >= RTMD5_HASH_SIZE, VERR_BUFFER_OVERFLOW); break; case RTDIGESTTYPE_SHA1: AssertReturn(cbHash >= RTSHA1_HASH_SIZE, VERR_BUFFER_OVERFLOW); break; case RTDIGESTTYPE_SHA256: AssertReturn(cbHash >= RTSHA256_HASH_SIZE, VERR_BUFFER_OVERFLOW); break; case RTDIGESTTYPE_SHA512: AssertReturn(cbHash >= RTSHA512_HASH_SIZE, VERR_BUFFER_OVERFLOW); break; default: if (enmDigest > RTDIGESTTYPE_INVALID && enmDigest < RTDIGESTTYPE_END) return VERR_NOT_SUPPORTED; AssertFailedReturn(VERR_INVALID_PARAMETER); } AssertPtrReturn(pabHash, VERR_INVALID_POINTER); /* * Call the image specific worker, if there is one. */ if (!pMod->pOps->pfnHashImage) return VERR_NOT_SUPPORTED; return pMod->pOps->pfnHashImage(pMod, enmDigest, pabHash, cbHash); } RT_EXPORT_SYMBOL(RTLdrHashImage); RTDECL(int) RTLdrUnwindFrame(RTLDRMOD hLdrMod, void const *pvBits, uint32_t iSeg, RTLDRADDR off, PRTDBGUNWINDSTATE pState) { /* * Validate. */ AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; AssertPtr(pState); AssertReturn(pState->u32Magic == RTDBGUNWINDSTATE_MAGIC, VERR_INVALID_MAGIC); /* * Pass on the work. */ if (pMod->pOps->pfnUnwindFrame) return pMod->pOps->pfnUnwindFrame(pMod, pvBits, iSeg, off, pState); return VERR_DBG_NO_UNWIND_INFO; } RT_EXPORT_SYMBOL(RTLdrUnwindFrame); /** * Internal method used by the IPRT debug bits. * * @returns IPRT status code. * @param hLdrMod The loader handle which executable we wish to * read from. * @param pvBuf The output buffer. * @param iDbgInfo The debug info ordinal number if the request * corresponds exactly to a debug info part from * pfnEnumDbgInfo. Otherwise, pass UINT32_MAX. * @param off Where in the executable file to start reading. * @param cb The number of bytes to read. * * @remarks Fixups will only be applied if @a iDbgInfo is specified. */ DECLHIDDEN(int) rtLdrReadAt(RTLDRMOD hLdrMod, void *pvBuf, uint32_t iDbgInfo, RTFOFF off, size_t cb) { AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE); PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod; if (iDbgInfo != UINT32_MAX) { AssertReturn(pMod->pOps->pfnReadDbgInfo, VERR_NOT_SUPPORTED); return pMod->pOps->pfnReadDbgInfo(pMod, iDbgInfo, off, cb, pvBuf); } AssertReturn(pMod->pReader, VERR_NOT_SUPPORTED); return pMod->pReader->pfnRead(pMod->pReader, pvBuf, cb, off); } RTDECL(const char *) RTLdrArchName(RTLDRARCH enmArch) { switch (enmArch) { case RTLDRARCH_INVALID: return "INVALID"; case RTLDRARCH_WHATEVER: return "WHATEVER"; case RTLDRARCH_HOST: return "HOST"; case RTLDRARCH_AMD64: return "AMD64"; case RTLDRARCH_X86_16: return "X86_16"; case RTLDRARCH_X86_32: return "X86_32"; case RTLDRARCH_ARM32: return "ARM32"; case RTLDRARCH_ARM64: return "ARM64"; case RTLDRARCH_END: case RTLDRARCH_32BIT_HACK: break; } return "UNKNOWN"; } RT_EXPORT_SYMBOL(RTLdrArchName);