wip

Author: emesare

view/sharedcache/api/python/sharedcache.py

@@ -1,5 +1,6 @@
 import ctypes
 import dataclasses
+from typing import Optional
 
 import binaryninja
 from binaryninja import BinaryView
@@ -22,7 +23,7 @@ def __str__(self):
         return repr(self)
 
     def __repr__(self):
-        return f"<CacheRegion '{self.name}': {self.start:x}+{self.size:x}>"
+        return f"<CacheRegion '{self.name}': 0x{self.start:x} + {self.size:x}>"
 
 @dataclasses.dataclass
 class CacheImage:
@@ -34,7 +35,19 @@ def __str__(self):
         return repr(self)
 
     def __repr__(self):
-        return f"<CacheImage '{self.name}': {self.header_address:x}>"
+        return f"<CacheImage '{self.name}': 0x{self.header_address:x}>"
+
+@dataclasses.dataclass
+class CacheSymbol:
+    symbol_type: sccore.SymbolTypeEnum
+    address: int
+    name: str
+
+    def __str__(self):
+        return repr(self)
+
+    def __repr__(self):
+        return f"<CacheSymbol '{self.name}': 0x{self.address:x}>"
 
 def region_from_api(region: sccore.BNSharedCacheRegion) -> CacheRegion:
     return CacheRegion(
@@ -57,21 +70,39 @@ def region_to_api(region: CacheRegion) -> sccore.BNSharedCacheRegion:
     )
 
 def image_from_api(image: sccore.BNSharedCacheImage) -> CacheImage:
+    region_starts = []
+    for i in range(image.regionStartCount):
+        region_starts.append(image.regionStarts[i])
     return CacheImage(
-        image.name,
-        image.headerAddress,
-        image.regionStarts
+        name=image.name,
+        header_address=image.headerAddress,
+        region_starts=region_starts
     )
 
 def image_to_api(image: CacheImage) -> sccore.BNSharedCacheImage:
-    region_start_array = (ctypes.POINTER(ctypes.c_ulonglong) * len(image.region_starts))()
+    region_start_array = (ctypes.c_ulonglong * len(image.region_starts))()
     for i, region_start in enumerate(image.region_starts):
-        region_start_array[i] = ctypes.c_ulonglong(region_start)
+        region_start_array[i] = region_start
+    core_region_starts = sccore.BNSharedCacheAllocRegionList(region_start_array, len(region_start_array))
     return sccore.BNSharedCacheImage(
         _name=BNAllocString(image.name),
         headerAddress=image.header_address,
         regionStartCount=len(region_start_array),
-        regionStarts=region_start_array
+        regionStarts=core_region_starts
+    )
+
+def symbol_from_api(symbol: sccore.BNSharedCacheSymbol) -> CacheSymbol:
+    return CacheSymbol(
+        symbol_type=symbol.symbolType,
+        address=symbol.address,
+        name=symbol.name
+    )
+
+def symbol_to_api(symbol: CacheSymbol) -> sccore.BNSharedCacheSymbol:
+    return sccore.BNSharedCacheSymbol(
+        symbolType=symbol.symbol_type,
+        address=symbol.address,
+        _name=BNAllocString(symbol.name)
     )
 
 class SharedCacheController:
@@ -90,6 +121,74 @@ def load_image(self, view: BinaryView, image: CacheImage) -> bool:
         sccore.BNSharedCacheFreeImage(api_image)
         return result
 
+    def is_region_loaded(self, region: CacheRegion) -> bool:
+        api_region: sccore.BNSharedCacheRegion = region_to_api(region)
+        result = sccore.BNSharedCacheControllerIsRegionLoaded(self.handle, api_region)
+        sccore.BNSharedCacheFreeRegion(api_region)
+        return result
+
+    def is_image_loaded(self, image: CacheImage) -> bool:
+        api_image: sccore.BNSharedCacheImage = image_to_api(image)
+        result = sccore.BNSharedCacheControllerIsImageLoaded(self.handle, api_image)
+        sccore.BNSharedCacheFreeImage(api_image)
+        return result
+
+    def get_region_at(self, address: int) -> Optional[CacheRegion]:
+        api_region = sccore.BNSharedCacheRegion()
+        if not sccore.BNSharedCacheControllerGetRegionAt(self.handle, address, api_region):
+            return None
+        region = region_from_api(api_region)
+        sccore.BNSharedCacheFreeRegion(api_region)
+        return region
+
+    def get_region_containing(self, address: int) -> Optional[CacheRegion]:
+        api_region = sccore.BNSharedCacheRegion()
+        if not sccore.BNSharedCacheControllerGetRegionContaining(self.handle, address, api_region):
+            return None
+        region = region_from_api(api_region)
+        sccore.BNSharedCacheFreeRegion(api_region)
+        return region
+
+    def get_image_at(self, address: int) -> Optional[CacheImage]:
+        api_image = sccore.BNSharedCacheImage()
+        if not sccore.BNSharedCacheControllerGetImageAt(self.handle, address, api_image):
+            return None
+        image = image_from_api(api_image)
+        sccore.BNSharedCacheFreeImage(api_image)
+        return image
+
+    def get_image_containing(self, address: int) -> Optional[CacheImage]:
+        api_image = sccore.BNSharedCacheImage()
+        if not sccore.BNSharedCacheControllerGetImageContaining(self.handle, address, api_image):
+            return None
+        image = image_from_api(api_image)
+        sccore.BNSharedCacheFreeImage(api_image)
+        return image
+
+    def get_image_with_name(self, name: str) -> Optional[CacheImage]:
+        api_image = sccore.BNSharedCacheImage()
+        if not sccore.BNSharedCacheControllerGetImageWithName(self.handle, name, api_image):
+            return None
+        image = image_from_api(api_image)
+        sccore.BNSharedCacheFreeImage(api_image)
+        return image
+
+    def get_image_dependencies(self, image: CacheImage) -> [str]:
+        """
+        Returns a list of image names that this image depends on.
+        """
+        count = ctypes.c_ulonglong()
+        api_image: sccore.BNSharedCacheImage = image_to_api(image)
+        value = sccore.BNSharedCacheControllerGetImageDependencies(self.handle, api_image, count)
+        sccore.BNSharedCacheFreeImage(api_image)
+        if value is None:
+            return []
+        result = []
+        for i in range(count.value):
+            result.append(value[i].decode("utf-8"))
+        BNFreeStringList(value, count)
+        return result
+
     @property
     def regions(self) -> [CacheRegion]:
         count = ctypes.c_ulonglong()
@@ -102,6 +201,21 @@ def regions(self) -> [CacheRegion]:
         sccore.BNSharedCacheFreeRegionList(value, count)
         return result
 
+    @property
+    def loaded_regions(self) -> [CacheRegion]:
+        """
+        Get a list of regions that are currently loaded in the view.
+        """
+        count = ctypes.c_ulonglong()
+        value = sccore.BNSharedCacheControllerGetLoadedRegions(self.handle, count)
+        if value is None:
+            return []
+        result = []
+        for i in range(count.value):
+            result.append(region_from_api(value[i]))
+        sccore.BNSharedCacheFreeRegionList(value, count)
+        return result
+
     @property
     def images(self) -> [CacheImage]:
         count = ctypes.c_ulonglong()
@@ -113,5 +227,32 @@ def images(self) -> [CacheImage]:
             result.append(image_from_api(value[i]))
         sccore.BNSharedCacheFreeImageList(value, count)
         return result
+
+    @property
+    def loaded_images(self) -> [CacheImage]:
+        """
+        Get a list of images that are currently loaded in the view.
+        """
+        count = ctypes.c_ulonglong()
+        value = sccore.BNSharedCacheControllerGetLoadedImages(self.handle, count)
+        if value is None:
+            return []
+        result = []
+        for i in range(count.value):
+            result.append(image_from_api(value[i]))
+        sccore.BNSharedCacheFreeImageList(value, count)
+        return result
+
+    @property
+    def symbols(self) -> [CacheSymbol]:
+        count = ctypes.c_ulonglong()
+        value = sccore.BNSharedCacheControllerGetSymbols(self.handle, count)
+        if value is None:
+            return []
+        result = []
+        for i in range(count.value):
+            result.append(symbol_from_api(value[i]))
+        sccore.BNSharedCacheFreeSymbolList(value, count)
+        return result
 
 

view/sharedcache/api/sharedcache.cpp

@@ -203,6 +203,20 @@ std::optional<CacheImage> SharedCacheController::GetImageWithName(const std::str
 	return image;
 }
 
+std::vector<std::string> SharedCacheController::GetImageDependencies(const CacheImage &image) const
+{
+	size_t count;
+	BNSharedCacheImage apiImage = ImageToApi(image);
+	char** dependencies = BNSharedCacheControllerGetImageDependencies(m_object, &apiImage, &count);
+	BNSharedCacheFreeImage(apiImage);
+	std::vector<std::string> result;
+	result.reserve(count);
+	for (size_t i = 0; i < count; i++)
+		result.emplace_back(dependencies[i]);
+	BNFreeStringList(dependencies, count);
+	return result;
+}
+
 std::optional<CacheSymbol> SharedCacheController::GetSymbolAt(uint64_t address) const
 {
 	BNSharedCacheSymbol apiSymbol;

view/sharedcache/api/sharedcacheapi.h

@@ -310,6 +310,8 @@ namespace SharedCacheAPI {
 		std::optional<CacheImage> GetImageContaining(uint64_t address) const;
 		std::optional<CacheImage> GetImageWithName(const std::string& name) const;
 
+		std::vector<std::string> GetImageDependencies(const CacheImage& image) const;
+
 		std::optional<CacheSymbol> GetSymbolAt(uint64_t address) const;
 		std::optional<CacheSymbol> GetSymbolWithName(const std::string& name) const;
 

view/sharedcache/api/sharedcachecore.h

@@ -125,13 +125,17 @@ extern "C"
 	SHAREDCACHE_FFI_API BNSharedCacheRegion* BNSharedCacheControllerGetRegions(BNSharedCacheController* controller, size_t* count);
 	SHAREDCACHE_FFI_API BNSharedCacheRegion* BNSharedCacheControllerGetLoadedRegions(BNSharedCacheController* controller, size_t* count);
 
+	SHAREDCACHE_FFI_API uint64_t* BNSharedCacheAllocRegionList(uint64_t* list, size_t count);
+
 	SHAREDCACHE_FFI_API void BNSharedCacheFreeRegion(BNSharedCacheRegion region);
 	SHAREDCACHE_FFI_API void BNSharedCacheFreeRegionList(BNSharedCacheRegion* regions, size_t count);
 
 	SHAREDCACHE_FFI_API bool BNSharedCacheControllerGetImageAt(BNSharedCacheController* controller, uint64_t address, BNSharedCacheImage* image);
 	SHAREDCACHE_FFI_API bool BNSharedCacheControllerGetImageContaining(BNSharedCacheController* controller, uint64_t address, BNSharedCacheImage* image);
 	SHAREDCACHE_FFI_API bool BNSharedCacheControllerGetImageWithName(BNSharedCacheController* controller, const char* name, BNSharedCacheImage* image);
 
+	SHAREDCACHE_FFI_API char** BNSharedCacheControllerGetImageDependencies(BNSharedCacheController* controller, BNSharedCacheImage* image, size_t* count);
+
 	SHAREDCACHE_FFI_API BNSharedCacheImage* BNSharedCacheControllerGetImages(BNSharedCacheController* controller, size_t* count);
 	SHAREDCACHE_FFI_API BNSharedCacheImage* BNSharedCacheControllerGetLoadedImages(BNSharedCacheController* controller, size_t* count);