coretrace-python-analyzer 0.19.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

coretrace_python/__init__.py

@@ -1,4 +1,4 @@
 """CoreTrace's Python static analysis frontend."""
 
-__version__ = "0.19.0"
+__version__ = "0.20.0"
 

coretrace_python/abstract/__init__.py

@@ -8,6 +8,7 @@ from coretrace_python.abstract.constants import (
 from coretrace_python.abstract.heap import (
     ATTRIBUTES,
     ELEMENTS,
+    KEYS,
     MUTATORS,
     AbstractObject,
     AliasSet,
@@ -24,6 +25,7 @@ from coretrace_python.abstract.values import AbstractValue, Truth
 __all__ = [
     "ATTRIBUTES",
     "ELEMENTS",
+    "KEYS",
     "MUTATORS",
     "AbstractObject",
     "AbstractValue",

coretrace_python/abstract/heap.py

@@ -6,7 +6,8 @@ globals and imported symbols by name, and the fields loaded from an object by fi
 Each value points to an ``AliasSet`` of objects, computed by a flow-insensitive
 points-to fixpoint over the SSA form; each object has two ``HeapLocation`` fields,
 ``elements`` for its items and ``attributes`` for its attributes, field-insensitive
-within each. Taint and dependence analyses key their states by these locations, so a
+within each, and a third, ``keys``, for the keys of a mapping, which only the taint
+engine fills. Taint and dependence analyses key their states by these locations, so a
 store, a mutating method call or a load on any alias reads and writes the same place.
 """
 
@@ -47,6 +48,8 @@ from coretrace_python.source import SourceSpan
 
 ELEMENTS = "elements"
 ATTRIBUTES = "attributes"
+# The keys of a mapping, stored by the taint engine; the points-to solver never fills it.
+KEYS = "keys"
 
 # Method names that store their arguments into the receiver's elements.
 MUTATORS = frozenset(

coretrace_python/cache.py

@@ -42,7 +42,7 @@ from coretrace_python.interprocedural import (
 from coretrace_python.semantic.symbols import SymbolId
 from coretrace_python.source import SourceId, SourceSpan
 
-CACHE_FORMAT = 11
+CACHE_FORMAT = 12
 
 
 @dataclass(frozen=True)
@@ -368,6 +368,7 @@ def _encode_arguments(arguments: Arguments) -> dict[str, Any]:
         "positional": list(arguments.positional),
         "keywords": [[name, value] for name, value in arguments.keywords],
         "unpacked": arguments.unpacked,
+        "keyword_unpacked": arguments.keyword_unpacked,
     }
 
 
@@ -375,11 +376,12 @@ def _decode_arguments(data: Mapping[str, Any]) -> Arguments:
     def denoted(value: Any) -> str | None:
         return None if value is None else _string(value)
 
-    unpacked = data["unpacked"]
-    if not isinstance(unpacked, bool):
-        raise TypeError(f"expected a boolean, got {unpacked!r}")
+    unpacked, keyword_unpacked = data["unpacked"], data["keyword_unpacked"]
+    if not isinstance(unpacked, bool) or not isinstance(keyword_unpacked, bool):
+        raise TypeError(f"expected booleans, got {unpacked!r} and {keyword_unpacked!r}")
     return Arguments(
         tuple(denoted(value) for value in data["positional"]),
         tuple((_string(name), denoted(value)) for name, value in data["keywords"]),
         unpacked,
+        keyword_unpacked,
     )

coretrace_python/dependency/advisories.py

@@ -263,4 +263,8 @@ def _condition(entry: Mapping[str, Any]) -> Condition:
         (condition.argument is None and condition.position is None) or condition.values or condition.default
     ):
         raise ValueError("a host condition names the URL argument, by keyword or position, and nothing else")
+    if condition.kind == "keyword_name" and (
+        condition.argument is not None or condition.position is not None or condition.values or condition.default
+    ):
+        raise ValueError("a keyword_name condition carries its text and nothing else")
     return condition

coretrace_python/dependency/correlation.py

@@ -23,7 +23,7 @@ from coretrace_python.findings import Confidence, Finding, Severity
 from coretrace_python.findings.refutation import Status, Verdict, Verdicts
 from coretrace_python.interprocedural import Arguments, CallSite, ExternalSymbol
 from coretrace_python.semantic.symbols import SymbolId
-from coretrace_python.taint import Sink, TaintFlow, TaintKind
+from coretrace_python.taint import KEYWORD_NAMES, Sink, TaintFlow, TaintKind
 from coretrace_python.taint.urls import UrlProof, redirects_disabled
 
 Affected = Mapping[SymbolId, tuple[Advisory, ...]]
@@ -72,13 +72,25 @@ def check_conditions(
     a ``host`` condition, what ``url`` proves of the value the attacker's input is passed
     in (``passed_as``). A host the URL's constant text fixes rules the call out when the
     call disables redirects; otherwise a redirect may still lead to a host the attacker
-    controls, and the condition stays pending with that uncertainty."""
+    controls, and the condition stays pending with that uncertainty. A ``keyword_name``
+    condition is met when the attacker's input is passed as the keys of a ``**`` mapping,
+    pending when the call expands a mapping whose keys are not established, and
+    contradicted by a call writing every keyword name."""
 
     if entry is None:
         return ConditionCheck()
     met: list[Condition] = []
     pending: list[Condition] = []
     for condition in entry.conditions:
+        if condition.kind == "keyword_name":
+            if any(keyword == KEYWORD_NAMES for _, keyword in passed_as):
+                met.append(condition)
+            elif arguments is None or arguments.keyword_unpacked:
+                pending.append(condition)
+            else:
+                names = ", ".join(sorted({name for name, _ in arguments.keywords}))
+                return ConditionCheck(tuple(met), tuple(pending), condition, names or None)
+            continue
         if condition.kind == "host":
             origin = url.origin if url is not None and _passed_in(condition, passed_as) else None
             if origin is None:
@@ -119,7 +131,8 @@ def ruled_out(module: str, site: CallSite, check: ConditionCheck) -> str:
     python.yaml.load(Loader=python.yaml.SafeLoader)``."""
 
     assert check.contradicted is not None and isinstance(site.target, ExternalSymbol)
-    argument = check.contradicted.argument or f"#{check.contradicted.position}"
+    contradicted = check.contradicted
+    argument = contradicted.argument or ("keywords" if contradicted.kind == "keyword_name" else f"#{contradicted.position}")
     passed = f"{argument} absent" if check.passed is None else f"{argument}={check.passed}"
     return f"{module}:{site.location.start_line} {site.target.symbol}({passed})"
 

coretrace_python/dependency/graph.py

@@ -154,7 +154,10 @@ class Condition:
     ``default`` says an absent argument means a vulnerable value. A ``host`` condition
     says the attacker must choose the host of the URL passed as ``argument`` (or at
     ``position``); the engine decides it from what the URL's constant text proves. A
-    ``semantic`` condition cannot be checked and is reported as pending review."""
+    ``keyword_name`` condition says the attacker must choose a keyword name of the call,
+    as an ORM alias expanded from a mapping; the engine decides it from the keys of what
+    the call expands with ``**``. A ``semantic`` condition cannot be checked and is
+    reported as pending review."""
 
     kind: str
     text: str

coretrace_python/interprocedural/callgraph.py

@@ -18,6 +18,7 @@ from typing import ClassVar
 from coretrace_python.analysis import Analysis, AnalysisContext, AnyAnalysis
 from coretrace_python.cfg import CFGError
 from coretrace_python.hir import nodes
+from coretrace_python.ir.defuse import DefUse, def_use
 from coretrace_python.ir.lowering import (
     MODULE_BODY,
     LoweringError,
@@ -26,6 +27,7 @@ from coretrace_python.ir.lowering import (
 )
 from coretrace_python.ir.model import (
     Await,
+    BuildDict,
     Call,
     Constant,
     FunctionIR,
@@ -68,11 +70,15 @@ class Arguments:
     (``python.yaml.FullLoader``), a constant as Python writes it (``True``, ``'/static'``),
     or None for anything else (a parameter, an expression). ``unpacked`` says the call
     unpacks ``*args`` or ``**kwargs``, so an argument it does not give explicitly may
-    still be given; after ``*args`` no position is known, and ``positional`` is empty."""
+    still be given; after ``*args`` no position is known, and ``positional`` is empty.
+    ``keyword_unpacked`` says the call expands a ``**mapping`` whose keys it does not
+    write, so a keyword name may be anything; a literal with constant keys is written out
+    as its keywords, and ``unpacked`` stays true for it only when ``*args`` is also given."""
 
     positional: tuple[str | None, ...] = ()
     keywords: tuple[tuple[str, str | None], ...] = ()
     unpacked: bool = False
+    keyword_unpacked: bool = False
 
     def given(self, keyword: str | None, position: int | None = None) -> tuple[bool, str | None] | None:
         """Whether the call gives an argument, by ``keyword`` or at ``position``, and what it
@@ -245,8 +251,45 @@ def derive_symbols(
 # passed as an argument is not recorded, so call sites stay small in the cache.
 MAX_CONSTANT_LENGTH = 64
 
+_DICT = SymbolId("python.builtins.dict")
+
+
+def _keyword_entries(
+    value: Value, symbols: Mapping[Value, SymbolId], defs: Mapping[Value, Instruction], uses: DefUse
+) -> tuple[tuple[str, Value], ...] | None:
+    """The keywords a ``**value`` gives when every name is established: the string keys
+    of a dict literal, the keywords of ``dict(...)``, through what they unpack in turn;
+    None when a key is computed, the mapping is built elsewhere, or anything but the
+    call uses it, since a store or a mutating call may add a key the literal does not
+    write."""
+
+    if len(uses.uses(value)) != 1:
+        return None
+    made = defs.get(value)
+    entries: list[tuple[str, Value]] = []
+    if isinstance(made, BuildDict):
+        for key, item in made.items:
+            constant = defs.get(key)
+            if not isinstance(constant, Constant) or not isinstance(constant.value, str):
+                return None
+            entries.append((constant.value, item))
+        nested = made.unpacked
+    elif isinstance(made, Call) and symbols.get(made.callee) == _DICT and not made.arguments and not made.starred:
+        nested = tuple(v for name, v in made.keywords if name is None)
+        entries.extend((name, v) for name, v in made.keywords if name is not None)
+    else:
+        return None
+    for inner in nested:
+        found = _keyword_entries(inner, symbols, defs, uses)
+        if found is None:
+            return None
+        entries.extend(found)
+    return tuple(entries)
+
 
-def _arguments(call: Call, symbols: Mapping[Value, SymbolId], defs: Mapping[Value, Instruction]) -> Arguments:
+def _arguments(
+    call: Call, symbols: Mapping[Value, SymbolId], defs: Mapping[Value, Instruction], uses: DefUse
+) -> Arguments:
     def denoted(value: Value) -> str | None:
         symbol = symbols.get(value)
         if symbol is not None:
@@ -257,10 +300,22 @@ def _arguments(call: Call, symbols: Mapping[Value, SymbolId], defs: Mapping[Valu
         written = repr(made.value)
         return written if len(written) <= MAX_CONSTANT_LENGTH else None
 
+    keywords: list[tuple[str, str | None]] = []
+    keyword_unpacked = False
+    for name, value in call.keywords:
+        if name is not None:
+            keywords.append((name, denoted(value)))
+            continue
+        entries = _keyword_entries(value, symbols, defs, uses)
+        if entries is None:
+            keyword_unpacked = True
+        else:
+            keywords.extend((key, denoted(item)) for key, item in entries)
     return Arguments(
         () if call.starred else tuple(denoted(value) for value in call.arguments),
-        tuple((name, denoted(value)) for name, value in call.keywords if name is not None),
-        bool(call.starred) or any(name is None for name, _ in call.keywords),
+        tuple(keywords),
+        bool(call.starred) or keyword_unpacked,
+        keyword_unpacked,
     )
 
 
@@ -480,6 +535,7 @@ class CallGraphAnalysis(Analysis[CallGraph]):
                 table=table,
             )
             defs = {i.result: i for block in ssa.blocks for i in block.instructions if i.result is not None}
+            uses = def_use(ssa)
             found: list[CallSite] = []
             for block in ssa.blocks:
                 for instruction in block.instructions:
@@ -489,7 +545,7 @@ class CallGraphAnalysis(Analysis[CallGraph]):
                                 name,
                                 instruction.location,
                                 targets.get(instruction.callee, UnknownTarget()),
-                                _arguments(instruction, symbols[name], defs),
+                                _arguments(instruction, symbols[name], defs, uses),
                             )
                         )
             sites[name] = tuple(found)

coretrace_python/taint/__init__.py

@@ -2,6 +2,7 @@
 
 from coretrace_python.semantic.symbols import Members
 from coretrace_python.taint.engine import (
+    KEYWORD_NAMES,
     EntryPointAnalysis,
     Taint,
     TaintAnalysis,
@@ -46,6 +47,7 @@ from coretrace_python.taint.templates import (
 
 __all__ = [
     "FILTER_FUNCTIONS",
+    "KEYWORD_NAMES",
     "TEXT_KINDS",
     "AuthorizationGuard",
     "BasePattern",

coretrace_python/taint/engine.py

@@ -18,6 +18,7 @@ from typing import ClassVar
 from coretrace_python.abstract import (
     ATTRIBUTES,
     ELEMENTS,
+    KEYS,
     HeapAnalysis,
     HeapFacts,
     HeapLocation,
@@ -130,12 +131,18 @@ class TaintFlow:
     # What the arguments of the sink call denote, to decide the conditions on them.
     sink_arguments: Arguments | None = None
     # How the tainted value is passed to the sink call: at a position, by a keyword, or
-    # (None, None) unpacked with ``*`` or ``**``; ``f(x, key=x)`` passes it twice.
+    # (None, None) unpacked with ``*`` or ``**``; ``f(x, key=x)`` passes it twice. The
+    # keyword ``KEYWORD_NAMES`` says the value's keys are the keyword names of the call.
     passed_as: frozenset[tuple[int | None, str | None]] = frozenset()
 
 
 Key = Value | HeapLocation
 
+# The ``keyword`` of a ``passed_as`` way whose value's keys become the keyword names of
+# the call: ``f(**m)`` passes the keys of ``m`` as ``(None, KEYWORD_NAMES)``.
+KEYWORD_NAMES = "**"
+_DICT = SymbolId("python.builtins.dict")
+
 
 class TaintFacts:
     def __init__(self, taints: Mapping[Key, Taint], flows: tuple[TaintFlow, ...]) -> None:
@@ -217,6 +224,14 @@ class _TaintProblem(DataflowProblem[State]):
             taint = taint.join(state.get(location, Taint.none()))
         return taint
 
+    def keyed(self, value: Value, state: Mapping[Key, Taint]) -> Taint:
+        """The taint of the keys of the mappings ``value`` points to."""
+
+        taint = Taint.none()
+        for location in self.heap.locations(value, KEYS):
+            taint = taint.join(state.get(location, Taint.none()))
+        return taint
+
     def initial(self) -> State:
         state: dict[Key, Taint] = {
             self.function.parameters[index]: Taint(source.kinds, frozenset({source}))
@@ -246,6 +261,17 @@ class _TaintProblem(DataflowProblem[State]):
                 self.store(state, instruction.object, ATTRIBUTES, state.get(instruction.value, Taint.none()))
             elif isinstance(instruction, SetItem):
                 self.store(state, instruction.object, ELEMENTS, state.get(instruction.value, Taint.none()))
+                key = state.get(instruction.key, Taint.none())
+                if key:
+                    self.store(state, instruction.object, KEYS, key)
+            elif isinstance(instruction, BuildDict):
+                keys = Taint.none()
+                for item_key, _ in instruction.items:
+                    keys = keys.join(state.get(item_key, Taint.none()))
+                for unpacked in instruction.unpacked:  # ``{**d}`` copies d's keys
+                    keys = keys.join(self.keyed(unpacked, state))
+                if keys:
+                    self.store(state, instruction.result, KEYS, keys)
             if instruction.result is None:
                 continue
             if isinstance(instruction, Phi):
@@ -352,6 +378,10 @@ class _TaintProblem(DataflowProblem[State]):
                     project, through, arguments, keywords, everything, call, flows, state, (), bound
                 )
                 return self.declared_clean(target.symbol, result)
+            if target.symbol == _DICT:
+                keys = self.constructed_keys(call, state)
+                if keys:
+                    self.store(state, call.result, KEYS, keys)
             symbol = target.symbol
             if not self.modelled(symbol):
                 # ``get_conn().execute`` derived ``app.database.get_conn.execute``; what
@@ -376,6 +406,23 @@ class _TaintProblem(DataflowProblem[State]):
             return self.external(returned, everything, call, state, flows)
         return everything.join(state.get(call.callee, Taint.none()))
 
+    def constructed_keys(self, call: Call, state: Mapping[Key, Taint]) -> Taint:
+        """What the keys of ``dict(...)`` carry: the keys of the mapping it copies
+        (``dict(m)``, ``dict(**m)``) and the first element of each pair of a sequence
+        literal (``dict([(k, v)])``); a keyword is a constant key, and an iterable built
+        elsewhere (``zip(...)``, a parameter) gives keys the engine cannot establish."""
+
+        taint = Taint.none()
+        for value in (*call.arguments[:1], *(v for name, v in call.keywords if name is None)):
+            taint = taint.join(self.keyed(value, state))
+            made = self.defs.get(value)
+            if isinstance(made, BuildList | BuildTuple | BuildSet) and not made.unpacked:
+                for element in made.elements:
+                    pair = self.defs.get(element)
+                    if isinstance(pair, BuildTuple | BuildList) and pair.elements:
+                        taint = taint.join(state.get(pair.elements[0], Taint.none()))
+        return taint
+
     def nonlocal_result(self, instruction: NonlocalResult, state: dict[Key, Taint]) -> Taint:
         """The taint a nested callee left in its nonlocal ``name``, in the caller's terms."""
 
@@ -455,6 +502,11 @@ class _TaintProblem(DataflowProblem[State]):
                 self.report(
                     flows, sink, self.rendered(argument, state), argument, call, None, None, None, given, keyword=name
                 )
+                if name is None:
+                    # The keys of a ``**mapping`` are keyword names of the call: only an
+                    # advisory asks who chooses a name, no other sink reads one.
+                    keys = self.keyed(argument, state).without(~TaintKind.ADVISORY)
+                    self.report(flows, sink, keys, argument, call, None, None, None, given, keyword=KEYWORD_NAMES)
         self.template_filters(symbol, call, given, state, flows)
         cleared = self.clearing.clears(symbol, given)
         if cleared:

{coretrace_python_analyzer-0.19.0.dist-info → coretrace_python_analyzer-0.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: coretrace-python-analyzer
-Version: 0.19.0
+Version: 0.20.0
 Summary: Static security analysis infrastructure for Python code
 Project-URL: Homepage, https://github.com/CoreTrace/coretrace-python-analyzer
 Project-URL: Repository, https://github.com/CoreTrace/coretrace-python-analyzer

{coretrace_python_analyzer-0.19.0.dist-info → coretrace_python_analyzer-0.20.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-coretrace_python/__init__.py,sha256=FWsRdqY0ZoJRj8rA--2DntUA3GU1JsrZdyrjQIAq5wE,76
+coretrace_python/__init__.py,sha256=CxDlOASpblTY0nlvktbHjBs1Ntjlqj8ulKKg0N6LV6c,76
 coretrace_python/__main__.py,sha256=V8DnYtRboISK2VCKm7DGHLREKvqLbqApyWlKBOs26wU,65
-coretrace_python/cache.py,sha256=XnUC677v8VQvlmLA_GQO376isHn6ZdSOOA0dRua0Foo,13716
+coretrace_python/cache.py,sha256=cXDJvi0GqEGwC9lK6TH_nMYIH64sgbZUToQMnf5lAA0,13908
 coretrace_python/cli.py,sha256=G5jhb6g6RgSRSjjS7DBgziIjUM1vTFwalJGvFHVKxrg,11225
 coretrace_python/engine.py,sha256=i_YckOVHZa_Mcwxgi2jsMkw8O49zHFQZ313mA_Xtl-4,37643
-coretrace_python/abstract/__init__.py,sha256=n5FNkV8Z4LmwG0r06KWdLj4N2CPSgAKwY3896tdmRgM,999
+coretrace_python/abstract/__init__.py,sha256=UK1yHTU4fldnW0W-e-nyPEOsqCnXqGPVv7LkxfyBMII,1021
 coretrace_python/abstract/constants.py,sha256=z4-e7IzysxzGi58wFFff1MlEoV8l7AZsB9EL-q6b7vY,9071
-coretrace_python/abstract/heap.py,sha256=OaESXFGC0qzyhAr76xrCu4skeDVzZM4wlenQqfMTkdk,9642
+coretrace_python/abstract/heap.py,sha256=uJAA0bYnN3-4fdESo6o4CzlYJSIpwlFLoyccacN6Uk8,9831
 coretrace_python/abstract/ranges.py,sha256=zEl9ee55u3E02tkYzzIvCCud5mYRKIUgZd9h_0-crCM,11547
 coretrace_python/abstract/strings.py,sha256=G5EGlhxjrpjU9TuXQifuVO-6MNMrUtZ_4S3nkMEvIuQ,4095
 coretrace_python/abstract/values.py,sha256=SQmgR8jo7cd8KJFDokejg-cFTjJU1CTBUPYyEvbMg-4,1739
@@ -94,9 +94,9 @@ coretrace_python/dataflow/__init__.py,sha256=N5uY8VTNjEk6-ARCgDkxr6uGqQIz2NbF-U9
 coretrace_python/dataflow/lattice.py,sha256=HgYGVcKVUlexvEc0yT47aQCudLxU_SWLpHhr17igkiE,1929
 coretrace_python/dataflow/solver.py,sha256=iDsW0wujhM2DXplu2JMKC46BRsroXlNETHPEoikPeG4,3475
 coretrace_python/dependency/__init__.py,sha256=BxkxnNwIEpAYtwbshCQovG-YXJ80QbwyzkmyJdbgsVg,1184
-coretrace_python/dependency/advisories.py,sha256=RPtqT5M_kmRVnjs53PRnDJKUsUysdJmk8KuE3sigUOk,10564
-coretrace_python/dependency/correlation.py,sha256=nr5FZ3yOT4HsKzvEAFlzzaPJxBc9_X-IuyOWtRjS67Q,9033
-coretrace_python/dependency/graph.py,sha256=U9KzdVCcM7P1W6qSSSMkzMIIVEh3qlzBpBi2FAFy0y0,18633
+coretrace_python/dependency/advisories.py,sha256=t1BKlfGx6GkPd0BNAWjli8-bIJj347A5zvfuWPO4rlw,10818
+coretrace_python/dependency/correlation.py,sha256=HsERzPR9A5NceRNh1dnNUO5B7saJFdXz0TrhI3c8IzY,9855
+coretrace_python/dependency/graph.py,sha256=ZaDSy1h3H4AS8kwGHV768wYf_R4KcqDnxzDQMsoIa88,18847
 coretrace_python/dependency/policy.py,sha256=bsxZXL9xC0jnAzkzDh6ncnW8oKLG2H13jYmXF_q99Ng,2454
 coretrace_python/dependency/sbom.py,sha256=rzJ-t0Mwoghej8nk0N63Dpjr_wYXm6JzuOPXjD8Kqs4,3234
 coretrace_python/dependency/vex.py,sha256=bafWyziWWQP-Fjw1bvyOcOPsdFMwKy-sjMGWL7IPY3w,8048
@@ -114,7 +114,7 @@ coretrace_python/hir/__init__.py,sha256=xMpvj-RSp6bd78a_hhkqbe99-snjERkH-_Lv5o9A
 coretrace_python/hir/nodes.py,sha256=4BI0f3UhKbnz9ZIxMoKXM7ujav0BmRpD0OXaoblRxIk,12364
 coretrace_python/hir/visitors.py,sha256=JFnX09hK6trLyRcWgZ5ehOG2ywX3VvkqQ1h82nahYNg,885
 coretrace_python/interprocedural/__init__.py,sha256=q8u1eIpM55wqVtn46cxuymOn5D5DWU7K35i8Nzzbc3w,1604
-coretrace_python/interprocedural/callgraph.py,sha256=EEG8kh9yyFPZiiFcouR8wuIwicClSKHu-z7nLh1kKOQ,22163
+coretrace_python/interprocedural/callgraph.py,sha256=a4LNbp8ZboIgwkNgWIzYHipS1yHwXvgQy33ariECRcE,24452
 coretrace_python/interprocedural/modulegraph.py,sha256=xKlO_L2mcZi0RoG9h2ulacYecqUhM5BG1RrdC6_HUk8,13036
 coretrace_python/interprocedural/summaries.py,sha256=6lybEynjtptZGGBw_3WKXx9ZZZqN96xL-r-tzo8fbMI,33862
 coretrace_python/ir/__init__.py,sha256=ShBPYYqoQFePP-mgBjGezQ2acel0-ReOHF9vCC-G_4Q,232
@@ -143,15 +143,15 @@ coretrace_python/semantic/symbols.py,sha256=G0jwsWFo2346Y1R2sztsB8HuZZm_aHfHSJXX
 coretrace_python/source/__init__.py,sha256=0Y8fvtbkETnNCJR9Zq7RS5TSgF9c22pz3SSk1KdAXF0,301
 coretrace_python/source/manager.py,sha256=JRmMOcWfS1nocbVrdcvfQTqEfIkmnb5JP857TpGywN4,2736
 coretrace_python/source/model.py,sha256=FZnN5mlir3tzbIpWoxnn6YtRi9UcJ_y0sZM60tKr8U4,1727
-coretrace_python/taint/__init__.py,sha256=nKpD33_4IRneAkd3Dt-j7Q-cHl47rDA_eLZFDHZVH28,1827
-coretrace_python/taint/engine.py,sha256=InunQrFgPq5NmiNkn0BQTTb_7D4IY_wZ2sJZn_K4iMs,51533
+coretrace_python/taint/__init__.py,sha256=Da0nmvrxm9uKsmQogtHdc-FRrWo_xxpnLBDCSQ-xp9g,1867
+coretrace_python/taint/engine.py,sha256=NvGhkBpBviCKE0BGHlgEgKacKC55fSxjwUwkaBz7pkk,54415
 coretrace_python/taint/models.py,sha256=pCvE-6dYKYSLK7pylxhLWpeUcMfMyXlh_1VUJbzieo8,20405
 coretrace_python/taint/routes.py,sha256=UAJKXcw_sM9shf58FfDroxVO9bNSm4qrQdZknwUB0lo,6110
 coretrace_python/taint/templates.py,sha256=gUpUvVk_UIVY2a3T5ENm2TfBuPCDhnu2lu8h50srZ4Q,43963
 coretrace_python/taint/urls.py,sha256=kb0-uOT12ww7R3Jzs_lPKg9lFs74JI-bpa9pXX105xM,3166
-coretrace_python_analyzer-0.19.0.dist-info/METADATA,sha256=QWl44X6mXg-aIRsdgMZIGyX-Ms3CvvpysboxggSRJi4,3217
-coretrace_python_analyzer-0.19.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-coretrace_python_analyzer-0.19.0.dist-info/entry_points.txt,sha256=wdozemiraOkbt65g_Y_zgspuZpoLxJdaCVMJt1Ft3c0,72
-coretrace_python_analyzer-0.19.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-coretrace_python_analyzer-0.19.0.dist-info/licenses/NOTICE,sha256=s3VHj5ngV0ozjW_kZJpg_35ne6JwoBK0ysOjbqVtA0w,113
-coretrace_python_analyzer-0.19.0.dist-info/RECORD,,
+coretrace_python_analyzer-0.20.0.dist-info/METADATA,sha256=iC4jLQhKfefmmGcBpJSgaVFWY-SassLvisc6EoUtdz4,3217
+coretrace_python_analyzer-0.20.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+coretrace_python_analyzer-0.20.0.dist-info/entry_points.txt,sha256=wdozemiraOkbt65g_Y_zgspuZpoLxJdaCVMJt1Ft3c0,72
+coretrace_python_analyzer-0.20.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+coretrace_python_analyzer-0.20.0.dist-info/licenses/NOTICE,sha256=s3VHj5ngV0ozjW_kZJpg_35ne6JwoBK0ysOjbqVtA0w,113
+coretrace_python_analyzer-0.20.0.dist-info/RECORD,,