Added support for proc/self/maps

manticore/native/memory.py

@@ -814,6 +814,64 @@ def __str__(self):
             ]
         )
 
+    def proc_self_mappings(self):
+        """
+        Returns a sorted list of all the mappings for this memory for /proc/self/maps.
+
+        :return: a list of mappings.
+        :rtype: list
+        """
+        result = []
+        # TODO: Device inode and private/shared permissions are unsupported
+        device = "00:00"
+        inode = 0
+        private_shared_perms = "-"
+        for m in self.maps:
+            if isinstance(m, AnonMap):
+                if m.name is not None:
+                    result.append(
+                        (
+                            m.start,
+                            m.end,
+                            m.perms + private_shared_perms,
+                            0,
+                            device,
+                            inode,
+                            "[" + m.name + "]",
+                        )
+                    )
+                else:
+                    result.append(
+                        (m.start, m.end, m.perms + private_shared_perms, 0, device, inode, "")
+                    )
+            elif isinstance(m, FileMap):
+                result.append(
+                    (
+                        m.start,
+                        m.end,
+                        m.perms + private_shared_perms,
+                        m._offset,
+                        device,
+                        inode,
+                        m._filename,
+                    )
+                )
+            else:
+                result.append(
+                    (m.start, m.end, m.perms + private_shared_perms, 0, device, inode, m.name)
+                )
+
+        return sorted(result)
+
+    @property
+    def __proc_self__(self):
+        return "\n".join(
+            [
+                f'{start:016x}-{end:016x} {p.replace(" ", "-"):>4s} {offset:08x} {device} {inode:9} {name or ""}'
+                for start, end, p, offset, device, inode, name in self.proc_self_mappings()
+            ]
+        )
+
     def _maps_in_range(self, start, end):
         """
         Generates the list of maps that overlaps with the range [start:end]

manticore/platforms/linux.py

@@ -152,6 +152,50 @@ def sync(self):
         return
 
 
+class ProcSelfMaps(File):
+    def __init__(self, flags, linux):
+        self.filename = "_proc_self_maps_"
+        with open(self.filename, "w") as mapsFile:
+            print(linux.current.memory.__proc_self__, file=mapsFile)
+        mode = mode_from_flags(flags)
+        if mode != "rb":
+            raise EnvironmentError("/proc/self/maps is only supported in read only mode")
+        self.file = open(self.filename, mode)
+
+    def __getstate__(self):
+        state = {"name": self.name, "mode": self.mode}
+        state["pos"] = None if self.closed else self.tell()
+        return state
+
+    def __setstate__(self, state):
+        name = state["name"]
+        mode = state["mode"]
+        closed = state["pos"] is None
+        pos = state["pos"]
+        try:
+            self.file = open(name, mode)
+            if closed:
+                self.file.close()
+        except IOError:
+            # If the file can't be opened anymore (should not typically happen)
+            self.file = None
+        if pos is not None:
+            self.seek(pos)
+
+    def stat(self):
+        try:
+            return os.fstat(self.fileno())
+        except OSError as e:
+            return -e.errno
+
+    def ioctl(self, request, argp):
+        try:
+            return fcntl.fcntl(self, request, argp)
+        except OSError as e:
+            logger.error(f"Invalid Fcntl request: {request}")
+            return -e.errno
+
+
 class Directory(File):
     def __init__(self, path, flags):
         assert os.path.isdir(path)
@@ -1531,6 +1575,8 @@ def _sys_open_get_file(self, filename, flags):
         if os.path.abspath(filename).startswith("/proc/self"):
             if filename == "/proc/self/exe":
                 filename = os.path.abspath(self.program)
+            elif filename == "/proc/self/maps":
+                return ProcSelfMaps(flags, self)
             else:
                 raise EnvironmentError("/proc/self is largely unsupported")