crosshair-tool 0.0.85__tar.gz → 0.0.87__tar.gz

{crosshair-tool-0.0.85 → crosshair_tool-0.0.87}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: crosshair-tool
-Version: 0.0.85
+Version: 0.0.87
 Summary: Analyze Python code for correctness using symbolic execution.
 Home-page: https://github.com/pschanely/CrossHair
 Author: Phillip Schanely
@@ -22,8 +22,43 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: dev
 License-File: LICENSE
+Requires-Dist: packaging
+Requires-Dist: typing-inspect>=0.7.1
+Requires-Dist: typing_extensions>=3.10.0
+Requires-Dist: z3-solver>=4.13.0.0
+Requires-Dist: importlib_metadata>=4.0.0
+Requires-Dist: pygls>=1.0.0
+Requires-Dist: typeshed-client>=2.0.5
+Provides-Extra: dev
+Requires-Dist: autodocsumm<1,>=0.2.2; extra == "dev"
+Requires-Dist: black==22.3.0; extra == "dev"
+Requires-Dist: deal>=4.13.0; extra == "dev"
+Requires-Dist: icontract>=2.4.0; extra == "dev"
+Requires-Dist: isort==5.11.5; extra == "dev"
+Requires-Dist: mypy==0.990; extra == "dev"
+Requires-Dist: numpy==1.23.4; python_version < "3.12" and extra == "dev"
+Requires-Dist: numpy==1.26.0; (python_version >= "3.12" and python_version < "3.13") and extra == "dev"
+Requires-Dist: numpy==2.0.1; python_version >= "3.13" and extra == "dev"
+Requires-Dist: pre-commit~=2.20; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: sphinx>=3.4.3; extra == "dev"
+Requires-Dist: sphinx-rtd-theme>=0.5.1; extra == "dev"
+Requires-Dist: rst2pdf>=0.102; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 <img src="https://raw.githubusercontent.com/pschanely/CrossHair/main/doc/source/logo-gray.png" width="5%" align="left">
 

{crosshair-tool-0.0.85 → crosshair_tool-0.0.87}/crosshair/__init__.py

@@ -15,7 +15,7 @@ from crosshair.statespace import StateSpace
 from crosshair.tracers import NoTracing, ResumedTracing
 from crosshair.util import IgnoreAttempt, debug
 
-__version__ = "0.0.85"  # Do not forget to update in setup.py!
+__version__ = "0.0.87"  # Do not forget to update in setup.py!
 __author__ = "Phillip Schanely"
 __license__ = "MIT"
 __status__ = "Alpha"

{crosshair-tool-0.0.85 → crosshair_tool-0.0.87}/crosshair/_mark_stacks.h

@@ -538,23 +538,6 @@ static const uint8_t _ch_DE_INSTRUMENT[256] = {
 #endif
 #endif
 
-/* Get the underlying opcode, stripping instrumentation */
-int _ch_Py_GetBaseOpcode(PyCodeObject *code, int i)
-{
-    int opcode = _PyCode_CODE(code)[i].op.code;
-    if (opcode == INSTRUMENTED_LINE) {
-        opcode = code->_co_monitoring->lines[i].original_opcode;
-    }
-    if (opcode == INSTRUMENTED_INSTRUCTION) {
-        opcode = code->_co_monitoring->per_instruction_opcodes[i];
-    }
-    int deinstrumented = _ch_DE_INSTRUMENT[opcode];
-    if (deinstrumented) {
-        return deinstrumented;
-    }
-    return _ch_PyOpcode_Deopt[opcode];
-}
-
 static int64_t *
 _ch_mark_stacks(PyCodeObject *code_obj, int len)
 {
@@ -602,14 +585,14 @@ _ch_mark_stacks(PyCodeObject *code_obj, int len)
         /* Scan instructions */
         for (i = 0; i < len;) {
             int64_t next_stack = stacks[i];
-            opcode = _ch_Py_GetBaseOpcode(code_obj, i);
+            opcode = code[i].op.code;
             uint8_t trace_enabled_here = _ch_TRACABLE_INSTRUCTIONS[opcode];
             enabled_tracing[i] |= trace_enabled_here;
             int oparg = 0;
             while (opcode == EXTENDED_ARG) {
                 oparg = (oparg << 8) | code[i].op.arg;
                 i++;
-                opcode = _ch_Py_GetBaseOpcode(code_obj, i);
+                opcode = code[i].op.code;
                 stacks[i] = next_stack;
             }
             int next_i = i + _ch_PyOpcode_Caches[opcode] + 1;

{crosshair-tool-0.0.85 → crosshair_tool-0.0.87}/crosshair/auditwall.py

@@ -1,4 +1,5 @@
 import importlib
+import inspect
 import os
 import sys
 import traceback
@@ -28,9 +29,10 @@ def reject(event: str, args: Tuple) -> None:
 
 
 def inside_module(modules: Iterable[ModuleType]) -> bool:
-    files = {m.__file__ for m in modules}
-    for frame, lineno in traceback.walk_stack(None):
-        if frame.f_code.co_filename in files:
+    """Checks whether the current call stack is inside one of the given modules."""
+    for frame, _lineno in traceback.walk_stack(None):
+        frame_module = inspect.getmodule(frame)
+        if frame_module and frame_module in modules:
             return True
     return False
 
@@ -60,7 +62,7 @@ def check_msvcrt_open(event: str, args: Tuple) -> None:
 _MODULES_THAT_CAN_POPEN: Optional[Set[ModuleType]] = None
 
 
-def modules_with_allowed_popen():
+def modules_with_allowed_subprocess():
     global _MODULES_THAT_CAN_POPEN
     if _MODULES_THAT_CAN_POPEN is None:
         allowed_module_names = ("_aix_support", "ctypes", "platform", "uuid")
@@ -74,13 +76,14 @@ def modules_with_allowed_popen():
 
 
 def check_subprocess(event: str, args: Tuple) -> None:
-    if not inside_module(modules_with_allowed_popen()):
+    if not inside_module(modules_with_allowed_subprocess()):
         reject(event, args)
 
 
 _SPECIAL_HANDLERS = {
     "open": check_open,
     "subprocess.Popen": check_subprocess,
+    "os.posix_spawn": check_subprocess,
     "msvcrt.open_osfhandle": check_msvcrt_open,
 }
 

{crosshair-tool-0.0.85 → crosshair_tool-0.0.87}/crosshair/libimpl/builtinslib.py

@@ -267,7 +267,7 @@ class SymbolicValue(CrossHairValue):
         self.snapshot = SnapshotRef(-1)
         self.python_type = typ
         if type(smtvar) is str:
-            self.var = self.__init_var__(typ, smtvar)
+            self.var: Any = self.__init_var__(typ, smtvar)
         else:
             self.var = smtvar
             # TODO test that smtvar's sort matches expected?
@@ -402,6 +402,10 @@ def crosshair_types_for_python_type(
     return _PYTYPE_TO_WRAPPER_TYPE.get(origin, ())
 
 
+def python_types_using_atomic_symbolics() -> Iterable[Type[AtomicSymbolicValue]]:
+    return _PYTYPE_TO_WRAPPER_TYPE.keys()
+
+
 class ModelingDirector:
     def __init__(self, *a) -> None:
         # Maps python type to the symbolic type we've chosen to represent it (on this iteration)
@@ -834,19 +838,6 @@ def setup_binops():
 
     setup_binop(_, {ops.lshift, ops.rshift})
 
-    _AND_MASKS_TO_MOD = {
-        # It's common to use & to mask low bits. We can avoid realization by converting
-        # these situations into mod operations.
-        0x01: 2,
-        0x03: 4,
-        0x07: 8,
-        0x0F: 16,
-        0x1F: 32,
-        0x3F: 64,
-        0x7F: 128,
-        0xFF: 256,
-    }
-
     def _(op: BinFn, a: Integral, b: Integral):
         with NoTracing():
             if isinstance(b, SymbolicInt):
@@ -857,9 +848,12 @@ def setup_binops():
             b = realize(b)
             if b == 0:
                 return 0
-            mask_mod = _AND_MASKS_TO_MOD.get(b)
-            if mask_mod and isinstance(a, SymbolicInt):
-                if context_statespace().smt_fork(a.var >= 0, probability_true=0.75):
+            # It's common to use & to mask low bits. We can avoid realization by converting
+            # these situations into mod operations.
+            mask_mod = b + 1
+            if b > 0 and mask_mod & b == 0 and isinstance(a, SymbolicInt):  # type: ignore
+                space = context_statespace()
+                if space.smt_fork(a.var >= 0, probability_true=0.75):
                     return SymbolicInt(a.var % mask_mod)
                 else:
                     return SymbolicInt(b - ((-a.var - 1) % mask_mod))
@@ -3488,10 +3482,6 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
                 otherpoints = [ord(ch) for ch in other]
                 with ResumedTracing():
                     return mypoints.__eq__(otherpoints)
-            elif isinstance(other, SeqBasedSymbolicStr):
-                with ResumedTracing():
-                    otherpoints = [ord(ch) for ch in other]
-                    return mypoints.__eq__(otherpoints)
             else:
                 return NotImplemented
 
@@ -3660,257 +3650,6 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
         return self._find(substr, start, end, from_right=True)
 
 
-class SeqBasedSymbolicStr(AtomicSymbolicValue, SymbolicSequence, AnySymbolicStr):
-    def __init__(self, smtvar: Union[str, z3.ExprRef], typ: Type = str):
-        assert typ == str
-        SymbolicValue.__init__(self, smtvar, typ)
-        self.item_pytype = str
-        if isinstance(smtvar, str):
-            # Constrain fresh strings to valid codepoints
-            space = context_statespace()
-            idxvar = z3.Int("idxvar" + space.uniq())
-            z3seq = self.var
-            space.add(
-                z3.ForAll(
-                    [idxvar], z3.And(0 <= z3seq[idxvar], z3seq[idxvar] <= maxunicode)
-                )
-            )
-
-    @classmethod
-    def _ch_smt_sort(cls) -> z3.SortRef:
-        return z3.SeqSort(z3.IntSort())
-
-    @classmethod
-    def _pytype(cls) -> Type:
-        return str
-
-    @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
-        if isinstance(literal, str):
-            if len(literal) <= 1:
-                if len(literal) == 0:
-                    return z3.Empty(z3.SeqSort(z3.IntSort()))
-                return z3.Unit(z3IntVal(ord(literal)))
-            return z3.Concat([z3.Unit(z3IntVal(ord(ch))) for ch in literal])
-        return None
-
-    def __ch_realize__(self) -> object:
-        codepoints = context_statespace().find_model_value(self.var)
-        return "".join(chr(x) for x in codepoints)
-
-    def __copy__(self):
-        return SeqBasedSymbolicStr(self.var)
-
-    def __hash__(self):
-        return hash(self.__str__())
-
-    @staticmethod
-    def _concat_strings(
-        a: Union[str, "SeqBasedSymbolicStr"], b: Union[str, "SeqBasedSymbolicStr"]
-    ) -> Union[str, "SeqBasedSymbolicStr"]:
-        assert not is_tracing()
-        # Assumes at least one argument is symbolic and not tracing
-        if isinstance(a, SeqBasedSymbolicStr) and isinstance(b, SeqBasedSymbolicStr):
-            return SeqBasedSymbolicStr(a.var + b.var)
-        elif isinstance(a, str) and isinstance(b, SeqBasedSymbolicStr):
-            return SeqBasedSymbolicStr(
-                SeqBasedSymbolicStr._coerce_to_smt_sort(a) + b.var
-            )
-        else:
-            assert isinstance(a, SeqBasedSymbolicStr)
-            assert isinstance(b, str)
-            return SeqBasedSymbolicStr(
-                a.var + SeqBasedSymbolicStr._coerce_to_smt_sort(b)
-            )
-
-    def __add__(self, other):
-        with NoTracing():
-            if isinstance(other, (SeqBasedSymbolicStr, str)):
-                return SeqBasedSymbolicStr._concat_strings(self, other)
-            if isinstance(other, AnySymbolicStr):
-                return NotImplemented
-            raise TypeError
-
-    def __radd__(self, other):
-        with NoTracing():
-            if isinstance(other, (SeqBasedSymbolicStr, str)):
-                return SeqBasedSymbolicStr._concat_strings(other, self)
-            if isinstance(other, AnySymbolicStr):
-                return NotImplemented
-            raise TypeError
-
-    def __mul__(self, other):
-        if isinstance(other, Integral):
-            if other <= 1:
-                return self if other == 1 else ""
-            # Note that in SymbolicInt, we attempt string multiplication via regex.
-            # Z3 cannot do much with a symbolic regex, so we case-split on
-            # the repetition count.
-            return SeqBasedSymbolicStr(z3.Concat(*[self.var for _ in range(other)]))
-        return NotImplemented
-
-    __rmul__ = __mul__
-
-    def __mod__(self, other):
-        return self.__str__() % realize(other)
-
-    def __contains__(self, other):
-        with NoTracing():
-            forced = force_to_smt_sort(other, SeqBasedSymbolicStr)
-            return SymbolicBool(z3.Contains(self.var, forced))
-
-    def __getitem__(self, i: Union[int, slice]):
-        with NoTracing():
-            idx_or_pair = process_slice_vs_symbolic_len(
-                context_statespace(), i, z3.Length(self.var)
-            )
-            if isinstance(idx_or_pair, tuple):
-                (start, stop) = idx_or_pair
-                smt_result = z3.Extract(self.var, start, stop - start)
-            else:
-                smt_result = z3.Unit(self.var[idx_or_pair])
-            return SeqBasedSymbolicStr(smt_result)
-
-    def endswith(self, substr):
-        with NoTracing():
-            smt_substr = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-            return SymbolicBool(z3.SuffixOf(smt_substr, self.var))
-
-    def find(self, substr, start=None, end=None):
-        if not isinstance(substr, str):
-            raise TypeError
-        with NoTracing():
-            space = context_statespace()
-            smt_my_len = z3.Length(self.var)
-            if start is None and end is None:
-                smt_start = z3IntVal(0)
-                smt_end = smt_my_len
-                smt_str = self.var
-                if len(substr) == 0:
-                    return 0
-            else:
-                (smt_start, smt_end) = flip_slice_vs_symbolic_len(
-                    space, slice(start, end, None), smt_my_len
-                )
-                if len(substr) == 0:
-                    # Add oddity of CPython. We can find the empty string when over-slicing
-                    # off the left side of the string, but not off the right:
-                    # ''.find('', 3, 4) == -1
-                    # ''.find('', -4, -3) == 0
-                    if space.smt_fork(smt_start > smt_my_len):
-                        return -1
-                    elif space.smt_fork(smt_start > 0):
-                        return SymbolicInt(smt_start)
-                    else:
-                        return 0
-                (smt_start, smt_end) = clip_range_to_symbolic_len(
-                    space, smt_start, smt_end, smt_my_len
-                )
-                smt_str = z3.SubString(self.var, smt_start, smt_end - smt_start)
-
-            smt_sub = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-            if space.smt_fork(z3.Contains(smt_str, smt_sub)):
-                return SymbolicInt(z3.IndexOf(smt_str, smt_sub, 0) + smt_start)
-            else:
-                return -1
-
-    def partition(self, sep: str):
-        if not isinstance(sep, str):
-            raise TypeError
-        if len(sep) == 0:
-            raise ValueError
-        with NoTracing():
-            space = context_statespace()
-            smt_str = self.var
-            smt_sep = force_to_smt_sort(sep, SeqBasedSymbolicStr)
-            if space.smt_fork(z3.Contains(smt_str, smt_sep)):
-                uniq = space.uniq()
-                # Divide my contents into 4 concatenated parts:
-                prefix = SeqBasedSymbolicStr(f"prefix{uniq}")
-                match1 = SeqBasedSymbolicStr(
-                    f"match1{uniq}"
-                )  # the first character of the match
-                match_tail = SeqBasedSymbolicStr(f"match_tail{uniq}")
-                suffix = SeqBasedSymbolicStr(f"suffix{uniq}")
-                space.add(z3.Length(match1.var) == 1)
-                space.add(smt_sep == z3.Concat(match1.var, match_tail.var))
-                space.add(smt_str == z3.Concat(prefix.var, smt_sep, suffix.var))
-                space.add(
-                    z3.Not(z3.Contains(z3.Concat(match_tail.var, suffix.var), smt_sep))
-                )
-                return (prefix, sep, suffix)
-            else:
-                return (self, "", "")
-
-    def rfind(self, substr, start=None, end=None) -> Union[int, SymbolicInt]:
-        if not isinstance(substr, str):
-            raise TypeError
-        with NoTracing():
-            space = context_statespace()
-            smt_my_len = z3.Length(self.var)
-            if start is None and end is None:
-                smt_start = z3IntVal(0)
-                smt_end = smt_my_len
-                smt_str = self.var
-                if len(substr) == 0:
-                    return SymbolicInt(smt_my_len)
-            else:
-                (smt_start, smt_end) = flip_slice_vs_symbolic_len(
-                    space, slice(start, end, None), smt_my_len
-                )
-                if len(substr) == 0:
-                    # Add oddity of CPython. We can find the empty string when over-slicing
-                    # off the left side of the string, but not off the right:
-                    # ''.find('', 3, 4) == -1
-                    # ''.find('', -4, -3) == 0
-                    if space.smt_fork(smt_start > smt_my_len):
-                        return -1
-                    elif space.smt_fork(smt_end < 0):
-                        return 0
-                    elif space.smt_fork(smt_end < smt_my_len):
-                        return SymbolicInt(smt_end)
-                    else:
-                        return SymbolicInt(smt_my_len)
-                (smt_start, smt_end) = clip_range_to_symbolic_len(
-                    space, smt_start, smt_end, smt_my_len
-                )
-                smt_str = z3.SubString(self.var, smt_start, smt_end - smt_start)
-            smt_sub = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-            if space.smt_fork(z3.Contains(smt_str, smt_sub)):
-                uniq = space.uniq()
-                # Divide my contents into 4 concatenated parts:
-                prefix = SeqBasedSymbolicStr(f"prefix{uniq}")
-                match1 = SeqBasedSymbolicStr(f"match1{uniq}")
-                match_tail = SeqBasedSymbolicStr(f"match_tail{uniq}")
-                suffix = SeqBasedSymbolicStr(f"suffix{uniq}")
-                space.add(z3.Length(match1.var) == 1)
-                space.add(smt_sub == z3.Concat(match1.var, match_tail.var))
-                space.add(smt_str == z3.Concat(prefix.var, smt_sub, suffix.var))
-                space.add(
-                    z3.Not(z3.Contains(z3.Concat(match_tail.var, suffix.var), smt_sub))
-                )
-                return SymbolicInt(smt_start + z3.Length(prefix.var))
-            else:
-                return -1
-
-    def rpartition(self, sep: str):
-        result = self.rsplit(sep, maxsplit=1)
-        if len(result) == 1:
-            return ("", "", self)
-        elif len(result) == 2:
-            return (result[0], sep, result[1])
-
-    def startswith(self, substr, start=None, end=None):
-        if isinstance(substr, tuple):
-            return any(self.startswith(s, start, end) for s in substr)
-        smt_substr = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-        if start is not None or end is not None:
-            # TODO: "".startswith("", 1) should be False, not True
-            return self[start:end].startswith(substr)
-        with NoTracing():
-            return SymbolicBool(z3.PrefixOf(smt_substr, self.var))
-
-
 def buffer_to_byte_seq(obj: object) -> Optional[Sequence[int]]:
     if isinstance(obj, (bytes, bytearray)):
         return list(obj)
@@ -4822,11 +4561,6 @@ def _ord(c: str) -> int:
     with NoTracing():
         if isinstance(c, LazyIntSymbolicStr):
             return c._codepoints[0]
-        elif isinstance(c, SeqBasedSymbolicStr):
-            space = context_statespace()
-            ret = SymbolicInt("ord" + space.uniq())
-            space.add(c.var == z3.Unit(ret.var))
-            return ret
     return ord(realize(c))
 
 

{crosshair-tool-0.0.85 → crosshair_tool-0.0.87}/crosshair/libimpl/builtinslib_test.py

@@ -2117,7 +2117,7 @@ def test_dict___bool___ok() -> None:
     check_states(f, CONFIRMED)
 
 
-def test_dict___iter__() -> None:
+def test_dict___iter___fail() -> None:
     def f(a: Dict[int, str]) -> List[int]:
         """
         post[a]: 5 in _

{crosshair-tool-0.0.85 → crosshair_tool-0.0.87}/crosshair/libimpl/typeslib_test.py

@@ -30,6 +30,7 @@ def test_mappingproxy_deep_realize(space):
     assert type(copy) is MappingProxyType
     with ResumedTracing():
         val_from_orig = orig[key]
-        val_from_copy = copy[key]
+        realized_key = deep_realize(key)
+    val_from_copy = copy[realized_key]
     assert type(val_from_orig) is SymbolicInt
     assert type(val_from_copy) is int