angr 9.2.174__cp310-abi3-win_amd64.whl → 9.2.176__cp310-abi3-win_amd64.whl

angr/procedures/definitions/parse_glibc.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import logging
+import sys
+import os
+import json
+from collections import OrderedDict
+
+from angr.sim_type import parse_file, ALL_TYPES
+
+l = logging.getLogger(name="parse_glibc")
+
+
+def main():
+
+    with open(sys.argv[1], encoding="utf-8") as f:
+        glibc_decls = f.readlines()
+
+    protos = {}
+    for c_decl in glibc_decls:
+        c_decl = c_decl.strip("\n")
+
+        # preprocessing
+        c_decl = c_decl.replace("FILE *", "FILE_t *")
+        c_decl = c_decl.replace("const ", "")
+        c_decl = c_decl.replace("*restrict ", "* ")
+
+        try:
+            parsed = parse_file(c_decl, predefined_types=ALL_TYPES)
+        except Exception as ex:  # pylint: disable=broad-exception-caught
+            l.warning("Cannot parse the function prototype for %s: %s.", c_decl, str(ex))
+            continue
+        parsed_decl = parsed[0]
+        if not parsed_decl:
+            l.warning("Cannot parse the function prototype for %s.", c_decl)
+            continue
+
+        func_name, func_proto = next(iter(parsed_decl.items()))
+        protos[func_name] = func_proto
+
+    # build the dictionary
+    d = {
+        "_t": "lib",
+        "library_names": [
+            "libc.so.0",
+            "libc.so.1",
+            "libc.so.2",
+            "libc.so.3",
+            "libc.so.4",
+            "libc.so.5",
+            "libc.so.6",
+            "libc.so.7",
+            "libc.so",
+        ],
+        "non_returning": [
+            "exit_group",
+            "exit",
+            "abort",
+            "pthread_exit",
+            "__assert_fail",
+            "longjmp",
+            "siglongjmp",
+            "__longjmp_chk",
+            "__siglongjmp_chk",
+        ],
+        "functions": OrderedDict(),
+    }
+    for func_name in sorted(protos):
+        proto = protos[func_name]
+        d["functions"][func_name] = {"proto": json.dumps(proto.to_json()).replace('"', "'")}
+
+    os.makedirs("common", exist_ok=True)
+    with open("common/glibc.json", "w", encoding="utf-8") as f:
+        f.write(json.dumps(d, indent="\t"))
+
+
+if __name__ == "__main__":
+    main()

angr/procedures/libc/fgets.py

@@ -10,7 +10,8 @@ class fgets(angr.SimProcedure):
     # pylint:disable=arguments-differ
 
     def run(self, dst, size, file_ptr):
-        size = size.zero_extend(self.arch.bits - self.arch.sizeof["int"])
+        if size.size() < self.arch.bits:
+            size = size.zero_extend(self.arch.bits - self.arch.sizeof["int"])
 
         # let's get the memory back for the file we're interested in and find the newline
         fd_offset = io_file_data_for_arch(self.state.arch)["fd"]

angr/procedures/posix/pthread.py

@@ -52,20 +52,20 @@ class pthread_cond_signal(angr.SimProcedure):
 
 class pthread_mutex_lock(angr.SimProcedure):
     """
-    A no-op.
+    Always returns 0 (SUCCESS).
     """
 
     def run(self, arg):
-        pass
+        return 0
 
 
 class pthread_mutex_unlock(angr.SimProcedure):
     """
-    A no-op.
+    Always returns 0 (SUCCESS).
     """
 
     def run(self, arg):
-        pass
+        return 0
 
 
 class pthread_once(angr.SimProcedure):

angr/procedures/stubs/format_parser.py

@@ -99,11 +99,11 @@ class FormatString:
                     elif fmt_spec.spec_type == b"c":
                         s_val = chr(c_val & 0xFF)
                     elif fmt_spec.spec_type == b"x":
-                        s_val = hex(c_val)[2:]
+                        s_val = f"{c_val:x}"[2:]
                     elif fmt_spec.spec_type == b"o":
-                        s_val = oct(c_val)[2:]
+                        s_val = f"{c_val:o}"[2:]
                     elif fmt_spec.spec_type == b"p":
-                        s_val = hex(c_val)
+                        s_val = f"{c_val:x}"
                     else:
                         raise SimProcedureError(f"Unimplemented format specifier '{fmt_spec.spec_type}'")
 

angr/sim_type.py

@@ -872,6 +872,8 @@ class SimTypePointer(SimTypeReg):
         self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
     ):  # pylint: disable=unused-argument
         # if pts_to is SimTypeBottom, we return a void*
+        if self.label is not None and name is not None:
+            return super().c_repr(name=name, full=full, memo=memo, indent=indent, name_parens=name_parens)
         if isinstance(self.pts_to, SimTypeBottom):
             out = "void*"
             if name is None:
@@ -2192,10 +2194,10 @@ class SimTypeRef(SimType):
     ) -> str:  # pylint: disable=unused-argument
         prefix = "unknown"
         if self.original_type is SimStruct:
-            prefix = "struct"
+            prefix = "struct "
         if name is None:
             name = ""
-        return f"{prefix}{name} {self.name}"
+        return f"{prefix}{self.label} {name}"
 
     def _init_str(self) -> str:
         original_type_name = self.original_type.__name__.split(".")[-1]
@@ -2289,7 +2291,10 @@ STDINT_TYPES = {
     "ssize_t": SimTypeLength(True),
     "ssize": SimTypeLength(False),
     "uintptr_t": SimTypeLong(False),
-    "wchar_t": SimTypeShort(True),
+    # wide-char types
+    "wchar_t": SimTypeShort(True, label="wchar_t"),
+    "wint_t": SimTypeInt(True, label="wint_t"),
+    "wctype_t": SimTypeInt(True, label="wctype_t"),
 }
 ALL_TYPES.update(STDINT_TYPES)
 
@@ -2313,6 +2318,8 @@ GLIBC_INTERNAL_BASIC_TYPES = {
     # https://github.com/bminor/glibc/blob/a01a13601c95f5d111d25557656d09fe661cfc89/sysdeps/unix/sysv/linux/x86/bits/siginfo-arch.h#L12
     "__clock_t": ALL_TYPES["uint32_t"],
     "__suseconds_t": ALL_TYPES["int64_t"],
+    "socklen_t": ALL_TYPES["uint32_t"],
+    "mode_t": ALL_TYPES["unsigned int"],
 }
 ALL_TYPES.update(GLIBC_INTERNAL_BASIC_TYPES)
 
@@ -2340,6 +2347,22 @@ GLIBC_EXTERNAL_BASIC_TYPES = {
     "rlim64_t": ALL_TYPES["uint64_t"],
     # https://github.com/bminor/glibc/blob/a01a13601c95f5d111d25557656d09fe661cfc89/bits/types/error_t.h#L22
     "error_t": ALL_TYPES["int"],
+    "sigset_t": ALL_TYPES["int"],
+    "sem_t": ALL_TYPES["int"],
+    "sighandler_t": SimTypePointer(ALL_TYPES["void"], label="sighandler_t"),
+    "comparison_fn_t": SimTypePointer(ALL_TYPES["void"], label="comparison_fn_t"),
+    "DIR": SimStruct({}, name="DIR"),
+    "glob_t": SimStruct({}, name="glob_t"),
+    "glob64_t": SimStruct({}, name="glob64_t"),
+    "__free_fn_t": SimTypePointer(ALL_TYPES["void"], label="__free_fn_t"),
+    "__action_fn_t": SimTypePointer(ALL_TYPES["void"], label="__action_fn_t"),
+    "__ftw_func_t": SimTypePointer(ALL_TYPES["void"], label="__ftw_func_t"),
+    "mbstate_t": SimStruct({}, name="mbstate_t"),
+    "fpos_t": SimStruct({}, name="fpos_t"),
+    "fpos64_t": SimStruct({}, name="fpos64_t"),
+    "regex_t": SimStruct({}, name="regex_t"),
+    "fd_set": SimStruct({}, name="fd_set"),
+    "dev_t": ALL_TYPES["int"],
 }
 ALL_TYPES.update(GLIBC_EXTERNAL_BASIC_TYPES)
 
@@ -3578,6 +3601,15 @@ def _decl_to_type(
                 if struct is not None:
                     from_global = True
                     struct = struct.with_arch(arch)
+            if struct is None:
+                # fallback to using decl.name as key directly
+                struct = ALL_TYPES.get(decl.name)
+                if struct is not None and isinstance(struct, SimStruct):
+                    from_global = True
+                    struct = struct.with_arch(arch)
+                else:
+                    # give up
+                    struct = None
             if struct is not None and not isinstance(struct, SimStruct):
                 raise AngrTypeError("Provided a non-SimStruct value for a type that must be a struct")
 
@@ -3722,7 +3754,7 @@ def _cpp_decl_to_type(
         for idx, param in enumerate(the_func.parameters):
             arg_type = param.type
             args.append(_cpp_decl_to_type(arg_type, extra_types, opaque_classes=opaque_classes))
-            arg_name = param.name if param.name is not None else f"unknown_{idx}"
+            arg_name = param.name if param.name is not None else f"arg_{idx}"
             arg_names.append(arg_name)
 
         args = tuple(args)
@@ -3769,7 +3801,7 @@ def _cpp_decl_to_type(
         for idx, param in enumerate(the_func.parameters):
             arg_type = param.type
             args.append(_cpp_decl_to_type(arg_type, extra_types, opaque_classes=opaque_classes))
-            arg_name = param.name if param.name is not None else f"unknown_{idx}"
+            arg_name = param.name if param.name is not None else f"arg_{idx}"
             arg_names.append(arg_name)
 
         args = tuple(args)
@@ -3791,8 +3823,11 @@ def _cpp_decl_to_type(
         elif lbl in ALL_TYPES:
             t = ALL_TYPES[lbl]
         elif opaque_classes is True:
-            # create a class without knowing the internal members
-            t = SimCppClass(unique_name=lbl, name=lbl, members={}, size=32)
+            # create a struct or a class without knowing the internal members
+            if decl.typename.classkey == "struct":
+                t = SimTypeRef(lbl.removeprefix("struct "), SimStruct)
+            else:
+                t = SimCppClass(unique_name=lbl, name=lbl, members={}, size=32)
         else:
             raise TypeError(f'Unknown type "{lbl}"')
 
@@ -3833,15 +3868,42 @@ def _cpp_decl_to_type(
 
 
 def normalize_cpp_function_name(name: str) -> str:
-    # strip access specifiers
-    prefixes = ["public:", "protected:", "private:"]
-    for pre in prefixes:
-        name = name.removeprefix(pre)
+    stripped_any = True
+    while stripped_any:
+        stripped_any = False
+        # strip virtual/static/inline/friend keywords
+        prefixes = ["virtual", "static", "inline", "friend"]
+        for pre in prefixes:
+            new_name = name.removeprefix(pre + " ")
+            if new_name != name:
+                name = new_name
+                stripped_any = True
+
+        # strip access specifiers
+        prefixes = ["public:", "protected:", "private:", "[thunk]:"]
+        for pre in prefixes:
+            new_name = name.removeprefix(pre)
+            if new_name != name:
+                name = new_name
+                stripped_any = True
+
+        new_name = name.strip()
+        if new_name != name:
+            name = new_name
+            stripped_any = True
+
+    if "void (__cdecl *)" in name:
+        name = name.replace("void (__cdecl *)", "void ")
 
     if name.startswith("operator"):
         # the return type is missing; give it a default type
         name = "int " + name
 
+    if " __int" in name:
+        name = name.replace(" __int64 ", " long long ")
+        name = name.replace(" __int32 ", " int ")
+        name = name.replace(" __int16 ", " short ")
+
     return name.removesuffix(";")
 
 

angr/simos/windows.py

@@ -440,7 +440,7 @@ class SimWindows(SimOS):
         :param state:               The state to get the syscall number from
         :param allow_unsupported:   Whether to return a "dummy" sycall instead of raising an unsupported exception
         """
-        if state.block(state.history.jump_source).bytes.hex() == "cd29":  # int 29h
+        if state.history.jump_source and state.block(state.history.jump_source).bytes.hex() == "cd29":  # int 29h
             return self.fastfail
         return None
 

angr/storage/memory_mixins/paged_memory/page_backer_mixins.py

@@ -192,7 +192,7 @@ class ConcreteBackerMixin(ClemoryBackerMixin):
 
         try:
             backer_iter = self._clemory_backer.backers(addr)
-            backer_start, backer = next(backer_iter)
+            backer_start, _backer = next(backer_iter)
         except StopIteration:
             return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 

angr/utils/constants.py

@@ -6,4 +6,4 @@ MAX_POINTSTO_BITS = -1330 * 8
 
 
 def is_alignment_mask(n):
-    return n in {0xFFFFFFFFFFFFFFE0, 0xFFFFFFFFFFFFFFF0, 0xFFFFFFE0, 0xFFFFFFF0, 0xFFFFFFFC, 0xFFFFFFF8}
+    return n in {0xFFFFFFFFFFFFFFE0, 0xFFFFFFFFFFFFFFF0, 0xFFFFFFC0, 0xFFFFFFE0, 0xFFFFFFF0, 0xFFFFFFFC, 0xFFFFFFF8}

angr/utils/library.py

@@ -206,6 +206,7 @@ def get_cpp_function_name(demangled_name: str) -> str:
     :param demangled_name: The demangled C++ function name.
     :return:               The qualified function name, excluding return type and parameters.
     """
+    demangled_name = demangled_name.strip()
     func_decls, _ = parse_cpp_file(demangled_name)
     if func_decls and len(func_decls) == 1:
         return next(iter(func_decls))

angr/utils/strings.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+
+def decode_utf16_string(data: bytes) -> str:
+    """
+    Decode a UTF-16 encoded string from a bytes object in a resilient manner.
+
+    :param data: The bytes object containing the UTF-16 encoded string.
+    :param errors: The error handling scheme. Default is 'strict'.
+                   Other options include 'ignore', 'replace', etc.
+    :return: The decoded string.
+    """
+    if len(data) % 2 == 1:
+        data = data[:-1]  # Trim off the last byte if the length is odd
+
+    # If no BOM, try to decode as little-endian first
+    try:
+        return data.decode("utf-16-le")
+    except UnicodeDecodeError:
+        return "<utf16-decode-error>"

{angr-9.2.174.dist-info → angr-9.2.176.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: angr
-Version: 9.2.174
+Version: 9.2.176
 Summary: A multi-architecture binary analysis toolkit, with the ability to perform dynamic symbolic execution and various static analyses on binaries
 License: BSD-2-Clause
 Project-URL: Homepage, https://angr.io/
@@ -16,12 +16,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cxxheaderparser
 Requires-Dist: GitPython
-Requires-Dist: archinfo==9.2.174
+Requires-Dist: archinfo==9.2.176
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.174
-Requires-Dist: cle==9.2.174
+Requires-Dist: claripy==9.2.176
+Requires-Dist: cle==9.2.176
 Requires-Dist: msgspec
 Requires-Dist: mulpyplexer
 Requires-Dist: networkx!=2.8.1,>=2.0
@@ -31,7 +31,7 @@ Requires-Dist: pycparser>=2.18
 Requires-Dist: pydemumble
 Requires-Dist: pyformlang
 Requires-Dist: pypcode<4.0,>=3.2.1
-Requires-Dist: pyvex==9.2.174
+Requires-Dist: pyvex==9.2.176
 Requires-Dist: rich>=13.1.0
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy