DyldSharedCache/DyldSharedCache.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2026 R. Thomas
 * Copyright 2017 - 2026 Quarkslab
 *
 * 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.
 */
#ifndef LIEF_DSC_DYLD_SHARED_CACHE_H
#define LIEF_DSC_DYLD_SHARED_CACHE_H
#include "LIEF/visibility.h"
#include "LIEF/iterators.hpp"
#include "LIEF/DyldSharedCache/Dylib.hpp"
#include "LIEF/DyldSharedCache/MappingInfo.hpp"
#include "LIEF/DyldSharedCache/SubCache.hpp"
 
#include "LIEF/asm/Instruction.hpp"
 
#include <memory>
#include <string>
#include <vector>
 
namespace LIEF {
class FileStream;

namespace dsc {
namespace details {
class DyldSharedCache;
}

class LIEF_API DyldSharedCache {
  public:
  enum class VERSION : uint32_t {
    UNKNOWN = 0,
 
    DYLD_95_3,    
    DYLD_195_5,   
    DYLD_239_3,   
    DYLD_360_14,  
    DYLD_421_1,   
    DYLD_832_7_1, 
    DYLD_940,     
    DYLD_1042_1,  
    DYLD_1231_3,  
    DYLD_1284_13, 

    UNRELEASED,
  };

  enum class DYLD_TARGET_PLATFORM : uint32_t {
    UNKNOWN = 0,
    MACOS = 1,
    IOS = 2,
    TVOS = 3,
    WATCHOS = 4,
    BRIDGEOS = 5,
    IOSMAC = 6,
    IOS_SIMULATOR = 7,
    TVOS_SIMULATOR = 8,
    WATCHOS_SIMULATOR = 9,
    DRIVERKIT = 10,
    VISIONOS = 11,
    VISIONOS_SIMULATOR = 12,
    FIRMWARE = 13,
    SEPOS = 14,
 
    ANY = 0xFFFFFFFF,
  };

  enum class DYLD_TARGET_ARCH {
    UNKNOWN = 0,
 
    I386,
 
    X86_64,
    X86_64H,
 
    ARMV5,
    ARMV6,
    ARMV7,
 
    ARM64,
    ARM64E,
  };

  using dylib_iterator = iterator_range<Dylib::Iterator>;

  using mapping_info_iterator = iterator_range<MappingInfo::Iterator>;

  using subcache_iterator = iterator_range<SubCache::Iterator>;
 
  using instructions_iterator = iterator_range<assembly::Instruction::Iterator>;
 
  DyldSharedCache(std::unique_ptr<details::DyldSharedCache> impl);
  ~DyldSharedCache();

  static std::unique_ptr<DyldSharedCache> from_path(const std::string& path,
                                                    const std::string& arch = "");

  static std::unique_ptr<DyldSharedCache>
      from_files(const std::vector<std::string>& path);

  std::string filename() const;

  VERSION version() const;

  std::string filepath() const;

  uint64_t load_address() const;

  std::string arch_name() const;

  DYLD_TARGET_PLATFORM platform() const;

  DYLD_TARGET_ARCH arch() const;

  std::unique_ptr<Dylib> find_lib_from_va(uint64_t va) const LIEF_LIFETIMEBOUND;

  std::unique_ptr<Dylib>
      find_lib_from_path(const std::string& path) const LIEF_LIFETIMEBOUND;

  std::unique_ptr<Dylib>
      find_lib_from_name(const std::string& name) const LIEF_LIFETIMEBOUND;

  bool has_subcaches() const;

  dylib_iterator libraries() const LIEF_LIFETIMEBOUND;

  mapping_info_iterator mapping_info() const;

  subcache_iterator subcaches() const;

  instructions_iterator disassemble(uint64_t va) const;

  std::vector<uint8_t> get_content_from_va(uint64_t va, uint64_t size) const;

  std::unique_ptr<DyldSharedCache>
      cache_for_address(uint64_t va) const LIEF_LIFETIMEBOUND;

  std::unique_ptr<DyldSharedCache> main_cache() const;

  std::unique_ptr<DyldSharedCache>
      find_subcache(const std::string& filename) const;

  result<uint64_t> va_to_offset(uint64_t va) const;

  FileStream& stream() const;

  FileStream& stream();

  void enable_caching(const std::string& target_cache_dir) const;

  void flush_cache() const;
 
  private:
  std::unique_ptr<details::DyldSharedCache> impl_;
};

inline std::unique_ptr<DyldSharedCache> load(const std::string& path,
                                             const std::string& arch = "") {
  return DyldSharedCache::from_path(path, arch);
}

inline std::unique_ptr<DyldSharedCache>
    load(const std::vector<std::string>& files) {
  return DyldSharedCache::from_files(files);
}
 
}
}
#endif