From 768f7c78465fb93936e5ca50a0ca712664fe54e7 Mon Sep 17 00:00:00 2001 From: kat Date: Sun, 6 Jul 2025 15:05:01 -0400 Subject: KernelCache rewrite --- view/kernelcache/api/kernelcacheapi.h | 487 ++++++++++++++++++---------------- 1 file changed, 262 insertions(+), 225 deletions(-) (limited to 'view/kernelcache/api/kernelcacheapi.h') diff --git a/view/kernelcache/api/kernelcacheapi.h b/view/kernelcache/api/kernelcacheapi.h index 35c53d78..aceb30a5 100644 --- a/view/kernelcache/api/kernelcacheapi.h +++ b/view/kernelcache/api/kernelcacheapi.h @@ -1,274 +1,311 @@ #pragma once #include -#include "../core/MetadataSerializable.hpp" -#include "../api/view/macho/machoview.h" #include "kernelcachecore.h" -using namespace BinaryNinja; +template +class KCRefCountObject { + void AddRefInternal() { m_refs.fetch_add(1); } -namespace KernelCacheAPI { - template - class KCRefCountObject { - void AddRefInternal() { m_refs.fetch_add(1); } + void ReleaseInternal() { + if (m_refs.fetch_sub(1) == 1) + delete this; + } - void ReleaseInternal() { - if (m_refs.fetch_sub(1) == 1) - delete this; - } - - public: - std::atomic m_refs; - T *m_object; +public: + std::atomic m_refs; + T *m_object; - KCRefCountObject() : m_refs(0), m_object(nullptr) {} + KCRefCountObject() : m_refs(0), m_object(nullptr) {} - virtual ~KCRefCountObject() {} + virtual ~KCRefCountObject() = default; - T *GetObject() const { return m_object; } + T *GetObject() const { return m_object; } - static T *GetObject(KCRefCountObject *obj) { - if (!obj) - return nullptr; - return obj->GetObject(); - } + static T *GetObject(KCRefCountObject *obj) { + if (!obj) + return nullptr; + return obj->GetObject(); + } - void AddRef() { AddRefInternal(); } + void AddRef() { AddRefInternal(); } - void Release() { ReleaseInternal(); } + void Release() { ReleaseInternal(); } - void AddRefForRegistration() { AddRefInternal(); } - }; + void AddRefForRegistration() { AddRefInternal(); } +}; - template - class KCCoreRefCountObject { - void AddRefInternal() { m_refs.fetch_add(1); } +template +class KCCoreRefCountObject { + void AddRefInternal() { m_refs.fetch_add(1); } - void ReleaseInternal() { - if (m_refs.fetch_sub(1) == 1) { - if (!m_registeredRef) - delete this; - } + void ReleaseInternal() { + if (m_refs.fetch_sub(1) == 1) { + if (!m_registeredRef) + delete this; } - - public: - std::atomic m_refs; - bool m_registeredRef = false; - T *m_object; - - KCCoreRefCountObject() : m_refs(0), m_object(nullptr) {} - - virtual ~KCCoreRefCountObject() {} - - T *GetObject() const { return m_object; } - - static T *GetObject(KCCoreRefCountObject *obj) { - if (!obj) - return nullptr; - return obj->GetObject(); + } + +public: + std::atomic m_refs; + bool m_registeredRef = false; + T *m_object; + + KCCoreRefCountObject() : m_refs(0), m_object(nullptr) {} + + virtual ~KCCoreRefCountObject() = default; + + T *GetObject() const { return m_object; } + + static T *GetObject(KCCoreRefCountObject *obj) { + if (!obj) + return nullptr; + return obj->GetObject(); + } + + void AddRef() { + if (m_object && (m_refs != 0)) + AddObjectReference(m_object); + AddRefInternal(); + } + + void Release() { + if (m_object) + FreeObjectReference(m_object); + ReleaseInternal(); + } + + void AddRefForRegistration() { m_registeredRef = true; } + + void ReleaseForRegistration() { + m_object = nullptr; + m_registeredRef = false; + if (m_refs == 0) + delete this; + } +}; + +template +class KCRef +{ + T* m_obj; +#ifdef BN_REF_COUNT_DEBUG + void* m_assignmentTrace = nullptr; +#endif + +public: + KCRef() : m_obj(NULL) {} + + KCRef(T* obj) : m_obj(obj) + { + if (m_obj) + { + m_obj->AddRef(); +#ifdef BN_REF_COUNT_DEBUG + m_assignmentTrace = BNRegisterObjectRefDebugTrace(typeid(T).name()); +#endif } - - void AddRef() { - if (m_object && (m_refs != 0)) - AddObjectReference(m_object); - AddRefInternal(); + } + + KCRef(const KCRef& obj) : m_obj(obj.m_obj) + { + if (m_obj) + { + m_obj->AddRef(); +#ifdef BN_REF_COUNT_DEBUG + m_assignmentTrace = BNRegisterObjectRefDebugTrace(typeid(T).name()); +#endif } - - void Release() { - if (m_object) - FreeObjectReference(m_object); - ReleaseInternal(); + } + + KCRef(KCRef&& other) : m_obj(other.m_obj) + { + other.m_obj = 0; +#ifdef BN_REF_COUNT_DEBUG + m_assignmentTrace = other.m_assignmentTrace; +#endif + } + + ~KCRef() + { + if (m_obj) + { + m_obj->Release(); +#ifdef BN_REF_COUNT_DEBUG + BNUnregisterObjectRefDebugTrace(typeid(T).name(), m_assignmentTrace); +#endif } - - void AddRefForRegistration() { m_registeredRef = true; } - - void ReleaseForRegistration() { - m_object = nullptr; - m_registeredRef = false; - if (m_refs == 0) - delete this; + } + + KCRef& operator=(const BinaryNinja::Ref& obj) + { +#ifdef BN_REF_COUNT_DEBUG + if (m_obj) + BNUnregisterObjectRefDebugTrace(typeid(T).name(), m_assignmentTrace); + if (obj.m_obj) + m_assignmentTrace = BNRegisterObjectRefDebugTrace(typeid(T).name()); +#endif + T* oldObj = m_obj; + m_obj = obj.m_obj; + if (m_obj) + m_obj->AddRef(); + if (oldObj) + oldObj->Release(); + return *this; + } + + KCRef& operator=(KCRef&& other) + { + if (m_obj) + { +#ifdef BN_REF_COUNT_DEBUG + BNUnregisterObjectRefDebugTrace(typeid(T).name(), m_assignmentTrace); +#endif + m_obj->Release(); } - }; + m_obj = other.m_obj; + other.m_obj = 0; +#ifdef BN_REF_COUNT_DEBUG + m_assignmentTrace = other.m_assignmentTrace; +#endif + return *this; + } + + KCRef& operator=(T* obj) + { +#ifdef BN_REF_COUNT_DEBUG + if (m_obj) + BNUnregisterObjectRefDebugTrace(typeid(T).name(), m_assignmentTrace); + if (obj) + m_assignmentTrace = BNRegisterObjectRefDebugTrace(typeid(T).name()); +#endif + T* oldObj = m_obj; + m_obj = obj; + if (m_obj) + m_obj->AddRef(); + if (oldObj) + oldObj->Release(); + return *this; + } + + operator T*() const + { + return m_obj; + } + + T* operator->() const + { + return m_obj; + } + + T& operator*() const + { + return *m_obj; + } + + bool operator!() const + { + return m_obj == NULL; + } + + bool operator==(const T* obj) const + { + return T::GetObject(m_obj) == T::GetObject(obj); + } + + bool operator==(const KCRef& obj) const + { + return T::GetObject(m_obj) == T::GetObject(obj.m_obj); + } + + bool operator!=(const T* obj) const + { + return T::GetObject(m_obj) != T::GetObject(obj); + } + + bool operator!=(const KCRef& obj) const + { + return T::GetObject(m_obj) != T::GetObject(obj.m_obj); + } + + bool operator<(const T* obj) const + { + return T::GetObject(m_obj) < T::GetObject(obj); + } + + bool operator<(const KCRef& obj) const + { + return T::GetObject(m_obj) < T::GetObject(obj.m_obj); + } + + T* GetPtr() const + { + return m_obj; + } +}; + - struct KCMemoryRegion { - uint64_t vmAddress; - uint64_t size; - std::string prettyName; - }; - struct BackingCacheMapping { +namespace KernelCacheAPI { + struct CacheMappingInfo + { uint64_t vmAddress; uint64_t size; uint64_t fileOffset; }; - struct BackingCache { - std::string path; - bool isPrimary; - std::vector mappings; - }; - - struct KCImageMemoryMapping { + struct CacheImage + { + uint64_t headerFileAddress; + uint64_t headerVirtualAddress; std::string name; - uint64_t vmAddress; - uint64_t size; - bool loaded; - uint64_t rawViewOffset; }; - struct KCImage { + struct CacheEntry + { + std::string path; std::string name; - uint64_t headerFileAddress; - std::vector mappings; + BNKernelCacheEntryType entryType; + std::vector mappings; }; - struct KCSymbol { + struct CacheSymbol + { + BNSymbolType type; uint64_t address; std::string name; - std::string image; - }; - using namespace BinaryNinja; - struct KernelCacheMachOHeader : public KernelCacheCore::MetadataSerializable { - uint64_t textBase = 0; - uint64_t loadCommandOffset = 0; - mach_header_64 ident; - std::string identifierPrefix; - std::string installName; - - std::vector> entryPoints; - std::vector m_entryPoints; //list of entrypoints - - symtab_command symtab; - dysymtab_command dysymtab; - dyld_info_command dyldInfo; - routines_command_64 routines64; - function_starts_command functionStarts; - std::vector moduleInitSections; - linkedit_data_command exportTrie; - linkedit_data_command chainedFixups {}; - - uint64_t relocationBase; - // Section and program headers, internally use 64-bit form as it is a superset of 32-bit - std::vector segments; //only three types of sections __TEXT, __DATA, __IMPORT - segment_command_64 linkeditSegment; - std::vector sections; - std::vector sectionNames; - - std::vector symbolStubSections; - std::vector symbolPointerSections; - - std::vector dylibs; - - build_version_command buildVersion; - std::vector buildToolVersions; - - bool dysymPresent = false; - bool dyldInfoPresent = false; - bool exportTriePresent = false; - bool chainedFixupsPresent = false; - bool routinesPresent = false; - bool functionStartsPresent = false; - bool relocatable = false; - - void Store(KernelCacheCore::SerializationContext& context) const { - MSS(textBase); - MSS(loadCommandOffset); - MSS_SUBCLASS(ident); - MSS(identifierPrefix); - MSS(installName); - MSS(entryPoints); - MSS(m_entryPoints); - MSS_SUBCLASS(symtab); - MSS_SUBCLASS(dysymtab); - MSS_SUBCLASS(dyldInfo); - MSS_SUBCLASS(routines64); - MSS_SUBCLASS(functionStarts); - MSS_SUBCLASS(moduleInitSections); - MSS_SUBCLASS(exportTrie); - MSS_SUBCLASS(chainedFixups); - MSS(relocationBase); - MSS_SUBCLASS(segments); - MSS_SUBCLASS(linkeditSegment); - MSS_SUBCLASS(sections); - MSS(sectionNames); - MSS_SUBCLASS(symbolStubSections); - MSS_SUBCLASS(symbolPointerSections); - MSS(dylibs); - MSS_SUBCLASS(buildVersion); - MSS_SUBCLASS(buildToolVersions); - MSS(dysymPresent); - MSS(dyldInfoPresent); - MSS(exportTriePresent); - MSS(chainedFixupsPresent); - MSS(routinesPresent); - MSS(functionStartsPresent); - MSS(relocatable); - } - - static KernelCacheMachOHeader Load(KernelCacheCore::DeserializationContext& context) { - KernelCacheMachOHeader header; - header.MSL(textBase); - header.MSL(loadCommandOffset); - header.MSL(ident); - header.MSL(identifierPrefix); - header.MSL(installName); - header.MSL(entryPoints); - header.MSL(m_entryPoints); - header.MSL(symtab); - header.MSL(dysymtab); - header.MSL(dyldInfo); - header.MSL(routines64); - header.MSL(functionStarts); - header.MSL(moduleInitSections); - header.MSL(exportTrie); - header.MSL(chainedFixups); - header.MSL(relocationBase); - header.MSL(segments); - header.MSL(linkeditSegment); - header.MSL(sections); - header.MSL(sectionNames); - header.MSL(symbolStubSections); - header.MSL(symbolPointerSections); - header.MSL(dylibs); - header.MSL(buildVersion); - header.MSL(buildToolVersions); - header.MSL(dysymPresent); - header.MSL(dyldInfoPresent); - header.MSL(exportTriePresent); - header.MSL(chainedFixupsPresent); - header.MSL(routinesPresent); - header.MSL(functionStartsPresent); - header.MSL(relocatable); - return header; - } + std::pair> DemangledName(BinaryNinja::BinaryView &view) const; + BinaryNinja::Ref GetBNSymbol(BinaryNinja::BinaryView& view) const; }; + std::string GetSymbolTypeAsString(const BNSymbolType& type); - class KernelCache : public KCCoreRefCountObject { + class KernelCacheController : public KCCoreRefCountObject { public: - KernelCache(Ref view); - - BNKCViewState GetState(); - static BNKCViewLoadProgress GetLoadProgress(Ref view); - static uint64_t FastGetImageCount(Ref view); + explicit KernelCacheController(BNKernelCacheController* controller); + static KCRef GetController(BinaryNinja::BinaryView& view); - bool LoadImageWithInstallName(const std::string& installName); - bool LoadImageContainingAddress(uint64_t addr); - std::vector GetAvailableImages(); + // Attempt to load the given image into the view. + // + // It is the callers responsibility to run linear sweep and update analysis, as you might want to add + // multiple images at a time. + bool ApplyImage(BinaryNinja::BinaryView& view, const CacheImage& image); - bool IsImageLoaded(const uint64_t address) const; + bool IsImageLoaded(const CacheImage& image) const; - std::vector LoadAllSymbolsAndWait(); + std::optional GetImageAt(uint64_t address) const; + std::optional GetImageContaining(uint64_t address) const; + std::optional GetImageWithName(const std::string& name) const; - std::string GetNameForAddress(uint64_t address); - std::string GetImageNameForAddress(uint64_t address); + std::vector GetImageDependencies(const CacheImage& image) const; - std::vector GetImages(); - std::vector GetLoadedImages(); + std::optional GetSymbolAt(uint64_t address) const; + std::optional GetSymbolWithName(const std::string& name) const; - std::optional GetMachOHeaderForImage(const std::string& name); - std::optional GetMachOHeaderForAddress(uint64_t address); + std::vector GetImages() const; + std::vector GetLoadedImages() const; + std::vector GetSymbols() const; }; -} \ No newline at end of file +} -- cgit v1.3.1