The Tor Browser / file revision

 // Copyright (c) 2007, Google Inc.

 // All rights reserved.

 //

 // Redistribution and use in source and binary forms, with or without

 // modification, are permitted provided that the following conditions are

 // met:

 //

 //     * Redistributions of source code must retain the above copyright

 // notice, this list of conditions and the following disclaimer.

 //     * Redistributions in binary form must reproduce the above

 // copyright notice, this list of conditions and the following disclaimer

 // in the documentation and/or other materials provided with the

 // distribution.

 //     * Neither the name of Google Inc. nor the names of its

 // contributors may be used to endorse or promote products derived from

 // this software without specific prior written permission.

 //

 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 //  dynamic_images.h

 //

 //    Implements most of the function of the dyld API, but allowing an

 //    arbitrary task to be introspected, unlike the dyld API which

 //    only allows operation on the current task.  The current implementation

 //    is limited to use by 32-bit tasks.

 #ifndef CLIENT_MAC_HANDLER_DYNAMIC_IMAGES_H__

 #define CLIENT_MAC_HANDLER_DYNAMIC_IMAGES_H__

 #include <mach/mach.h>

 #include <mach-o/dyld.h>

 #include <mach-o/loader.h>

 #include <sys/types.h>

 #include <string>

 #include <vector>

 #include "mach_vm_compat.h"

 namespace google_breakpad {

 using std::string;

 using std::vector;

 //==============================================================================

 // The memory layout of this struct matches the dyld_image_info struct

 // defined in "dyld_gdb.h" in the darwin source.

 typedef struct dyld_image_info32 {

   uint32_t                   load_address_;  // struct mach_header*

   uint32_t                   file_path_;     // char*

   uint32_t                   file_mod_date_;

 } dyld_image_info32;

 typedef struct dyld_image_info64 {

   uint64_t                   load_address_;  // struct mach_header*

   uint64_t                   file_path_;     // char*

   uint64_t                   file_mod_date_;

 } dyld_image_info64;

 //==============================================================================

 // This is as defined in "dyld_gdb.h" in the darwin source.

 // _dyld_all_image_infos (in dyld) is a structure of this type

 // which will be used to determine which dynamic code has been loaded.

 typedef struct dyld_all_image_infos32 {

   uint32_t                      version;  // == 1 in Mac OS X 10.4

   uint32_t                      infoArrayCount;

   uint32_t                      infoArray;  // const struct dyld_image_info*

   uint32_t                      notification;

   bool                          processDetachedFromSharedRegion;

 } dyld_all_image_infos32;

 typedef struct dyld_all_image_infos64 {

   uint32_t                      version;  // == 1 in Mac OS X 10.4

   uint32_t                      infoArrayCount;

   uint64_t                      infoArray;  // const struct dyld_image_info*

   uint64_t                      notification;

   bool                          processDetachedFromSharedRegion;

 } dyld_all_image_infos64;

 // some typedefs to isolate 64/32 bit differences

 #ifdef __LP64__

 typedef mach_header_64 breakpad_mach_header;

 typedef segment_command_64 breakpad_mach_segment_command;

 #else

 typedef mach_header breakpad_mach_header;

 typedef segment_command breakpad_mach_segment_command;

 #endif

 // Helper functions to deal with 32-bit/64-bit Mach-O differences.

 class DynamicImage;

 template<typename MachBits>

 bool FindTextSection(DynamicImage& image);

 template<typename MachBits>

 uint32_t GetFileTypeFromHeader(DynamicImage& image);

 //==============================================================================

 // Represents a single dynamically loaded mach-o image

 class DynamicImage {

  public:

   DynamicImage(uint8_t *header,     // data is copied

                size_t header_size,  // includes load commands

                uint64_t load_address,

                string file_path,

                uintptr_t image_mod_date,

                mach_port_t task,

                cpu_type_t cpu_type)

     : header_(header, header + header_size),

       header_size_(header_size),

       load_address_(load_address),

       vmaddr_(0),

       vmsize_(0),

       slide_(0),

       version_(0),

       file_path_(file_path),

       file_mod_date_(image_mod_date),

       task_(task),

       cpu_type_(cpu_type) {

     CalculateMemoryAndVersionInfo();

   }

   // Size of mach_header plus load commands

   size_t GetHeaderSize() const {return header_.size();}

   // Full path to mach-o binary

   string GetFilePath() {return file_path_;}

   uint64_t GetModDate() const {return file_mod_date_;}

   // Actual address where the image was loaded

   uint64_t GetLoadAddress() const {return load_address_;}

   // Address where the image should be loaded

   mach_vm_address_t GetVMAddr() const {return vmaddr_;}

   // Difference between GetLoadAddress() and GetVMAddr()

   ptrdiff_t GetVMAddrSlide() const {return slide_;}

   // Size of the image

   mach_vm_size_t GetVMSize() const {return vmsize_;}

   // Task owning this loaded image

   mach_port_t GetTask() {return task_;}

   // CPU type of the task

   cpu_type_t GetCPUType() {return cpu_type_;}

   // filetype from the Mach-O header.

   uint32_t GetFileType();

   // Return true if the task is a 64-bit architecture.

   bool Is64Bit() { return (GetCPUType() & CPU_ARCH_ABI64) == CPU_ARCH_ABI64; }

   uint32_t GetVersion() {return version_;}

   // For sorting

   bool operator<(const DynamicImage &inInfo) {

     return GetLoadAddress() < inInfo.GetLoadAddress();

   }

   // Sanity checking

   bool IsValid() {return GetVMSize() != 0;}

  private:

   DynamicImage(const DynamicImage &);

   DynamicImage &operator=(const DynamicImage &);

   friend class DynamicImages;

   template<typename MachBits>

   friend bool FindTextSection(DynamicImage& image);

   template<typename MachBits>

   friend uint32_t GetFileTypeFromHeader(DynamicImage& image);

   // Initializes vmaddr_, vmsize_, and slide_

   void CalculateMemoryAndVersionInfo();

   const vector<uint8_t>   header_;        // our local copy of the header

   size_t                  header_size_;    // mach_header plus load commands

   uint64_t                load_address_;   // base address image is mapped into

   mach_vm_address_t       vmaddr_;

   mach_vm_size_t          vmsize_;

   ptrdiff_t               slide_;

   uint32_t                version_;        // Dylib version

   string                  file_path_;     // path dyld used to load the image

   uintptr_t               file_mod_date_;  // time_t of image file

   mach_port_t             task_;

   cpu_type_t              cpu_type_;        // CPU type of task_

 };

 //==============================================================================

 // DynamicImageRef is just a simple wrapper for a pointer to

 // DynamicImage.  The reason we use it instead of a simple typedef is so

 // that we can use stl::sort() on a vector of DynamicImageRefs

 // and simple class pointers can't implement operator<().

 //

 class DynamicImageRef {

  public:

   explicit DynamicImageRef(DynamicImage *inP) : p(inP) {}

   // The copy constructor is required by STL

   DynamicImageRef(const DynamicImageRef &inRef) : p(inRef.p) {}

   bool operator<(const DynamicImageRef &inRef) const {

     return (*const_cast<DynamicImageRef*>(this)->p)

       < (*const_cast<DynamicImageRef&>(inRef).p);

   }

   bool operator==(const DynamicImageRef &inInfo) const {

     return (*const_cast<DynamicImageRef*>(this)->p).GetLoadAddress() ==

         (*const_cast<DynamicImageRef&>(inInfo)).GetLoadAddress();

   }

   // Be just like DynamicImage*

   DynamicImage  *operator->() {return p;}

   operator DynamicImage*() {return p;}

  private:

   DynamicImage  *p;

 };

 // Helper function to deal with 32-bit/64-bit Mach-O differences.

 class DynamicImages;

 template<typename MachBits>

 void ReadImageInfo(DynamicImages& images, uint64_t image_list_address);

 //==============================================================================

 // An object of type DynamicImages may be created to allow introspection of

 // an arbitrary task's dynamically loaded mach-o binaries.  This makes the

 // assumption that the current task has send rights to the target task.

 class DynamicImages {

  public:

   explicit DynamicImages(mach_port_t task);

   ~DynamicImages() {

     for (int i = 0; i < GetImageCount(); ++i) {

       delete image_list_[i];

     }

   }

   // Returns the number of dynamically loaded mach-o images.

   int GetImageCount() const {return static_cast<int>(image_list_.size());}

   // Returns an individual image.

   DynamicImage *GetImage(int i) {

     if (i < (int)image_list_.size()) {

       return image_list_[i];

     }

     return NULL;

   }

   // Returns the image corresponding to the main executable.

   DynamicImage *GetExecutableImage();

   int GetExecutableImageIndex();

   // Returns the task which we're looking at.

   mach_port_t GetTask() const {return task_;}

   // CPU type of the task

   cpu_type_t GetCPUType() {return cpu_type_;}

   // Return true if the task is a 64-bit architecture.

   bool Is64Bit() { return (GetCPUType() & CPU_ARCH_ABI64) == CPU_ARCH_ABI64; }

   // Determine the CPU type of the task being dumped.

   static cpu_type_t DetermineTaskCPUType(task_t task);

   // Get the native CPU type of this task.

   static cpu_type_t GetNativeCPUType() {

 #if defined(__i386__)

     return CPU_TYPE_I386;

 #elif defined(__x86_64__)

     return CPU_TYPE_X86_64;

 #elif defined(__ppc__)

     return CPU_TYPE_POWERPC;

 #elif defined(__ppc64__)

     return CPU_TYPE_POWERPC64;

 #elif defined(__arm__)

     return CPU_TYPE_ARM;

 #else

 #error "GetNativeCPUType not implemented for this architecture"

 #endif

   }

  private:

   template<typename MachBits>

   friend void ReadImageInfo(DynamicImages& images, uint64_t image_list_address);

   bool IsOurTask() {return task_ == mach_task_self();}

   // Initialization

   void ReadImageInfoForTask();

   uint64_t GetDyldAllImageInfosPointer();

   mach_port_t              task_;

   cpu_type_t               cpu_type_;  // CPU type of task_

   vector<DynamicImageRef>  image_list_;

 };

 // Fill bytes with the contents of memory at a particular

 // location in another task.

 kern_return_t ReadTaskMemory(task_port_t target_task,

                              const uint64_t address,

                              size_t length,

                              vector<uint8_t> &bytes);

 }   // namespace google_breakpad

 #endif // CLIENT_MAC_HANDLER_DYNAMIC_IMAGES_H__