io.github.rohith1125/sentinel-execution-mcp

version 0.1.2

scanned 2026-10-16
source github.com/rohith1125/sentinel-execution-mcp
commit 2f8bc9f34d83
transport stdio
files read 2736
methodology 0.2.0
ruleset 0.1.1

Code Safetyweight 30

0measured on 99% of this axis

scored on the declared repository, because the published package carries its code only as build output, which is not read as the server's own source; no tag matched this version, so the repository's default branch was read and the findings describe that code, not necessarily the release; 1 file could not be parsed and was not scanned

Auth Postureweight 20

100measured on 65% of this axis

Dependency Healthweight 20

not assessed

no lockfile in the fetched source; dependency versions are unresolved, so no vulnerability can be attributed

Maintenanceweight 15

30measured on 45% of this axis

Transparencyweight 15

The evidence

Every deduction below names the artefact that produced it. Nothing on this page was executed: the source was read, never run, and no running server was contacted.

Code Safety

Showing the 50 most severe of 120 findings on this axis. The score was computed over all of them — findings beyond the fourth of a severity still deduct at a tenth of their weight — so the remainder is omitted from this page, not from the arithmetic.

packages/engine/.venv312/lib/python3.12/site-packages/_pytest/_code/code.py:170mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
        f_locals = self.f_locals.copy()
        f_locals.update(vars)
        return eval(code, self.f_globals, f_locals)

    def repr(self, object: object) -> str:
```
packages/engine/.venv312/lib/python3.12/site-packages/_pytest/_py/path.py:1153mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
                try:
                    with open(str(self), "rb") as f:
                        exec(f.read(), mod.__dict__)
                except BaseException:
                    del sys.modules[modname]
```
packages/engine/.venv312/lib/python3.12/site-packages/_pytest/assertion/rewrite.py:197mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
        else:
            state.trace(f"found cached rewritten pyc for {fn}")
        exec(co, module.__dict__)

    def _early_rewrite_bailout(self, name: str, state: AssertionState) -> bool:
```
packages/engine/.venv312/lib/python3.12/site-packages/_pytest/mark/expression.py:353mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
            matcher supports all expressions.
        """
        return bool(eval(self._code, {"__builtins__": {}}, MatcherAdapter(matcher)))
```
packages/engine/.venv312/lib/python3.12/site-packages/_pytest/pytester.py:295mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
                if call._name == name:
                    print("NAMEMATCH", name, call)
                    if eval(check, backlocals, call.__dict__):
                        print("CHECKERMATCH", repr(check), "->", call)
                    else:
```
packages/engine/.venv312/lib/python3.12/site-packages/_pytest/skipping.py:119mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
            filename = f"<{mark.name} condition>"
            condition_code = compile(condition, filename, "eval")
            result = eval(condition_code, globals_)
        except SyntaxError as exc:
            msglines = [
```
packages/engine/.venv312/lib/python3.12/site-packages/alembic/operations/base.py:189mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
            lcl: Dict[str, Any] = {}

            exec(func_text, globals_, lcl)
            setattr(cls, name, lcl[name])
            fn.__func__.__doc__ = (
```
packages/engine/.venv312/lib/python3.12/site-packages/alembic/util/langhelpers.py:219mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
        lcl: MutableMapping[str, Any] = {}

        exec(func_text, cast("Dict[str, Any]", globals_), lcl)
        return cast("Callable[..., Any]", lcl[name])
```
packages/engine/.venv312/lib/python3.12/site-packages/anyio/to_interpreter.py:130mcp-python-pickle-loads (critical/medium)
Attacker-reachable input is unpickled. pickle executes constructors during load, so a crafted payload is arbitrary code execution — this is not a hardening issue, it is the documented behaviour of the format.
```
            (res, is_exception), fmt = res[:2]
            if fmt == FMT_PICKLED:
                res = pickle.loads(res)

            if is_exception:
```
packages/engine/.venv312/lib/python3.12/site-packages/anyio/to_process.py:94mcp-python-pickle-loads (critical/medium)
Attacker-reachable input is unpickled. pickle executes constructors during load, so a crafted payload is arbitrary code execution — this is not a hardening issue, it is the documented behaviour of the format.
```
                raise BrokenWorkerProcess from exc

        retval = pickle.loads(pickled_response)
        if status == b"EXCEPTION":
            assert isinstance(retval, BaseException)
```
packages/engine/.venv312/lib/python3.12/site-packages/anyio/to_process.py:218mcp-python-pickle-loads (critical/medium)
Attacker-reachable input is unpickled. pickle executes constructors during load, so a crafted payload is arbitrary code execution — this is not a hardening issue, it is the documented behaviour of the format.
```
        retval = exception = None
        try:
            command, *args = pickle.load(stdin.buffer)
        except EOFError:
            return
```
packages/engine/.venv312/lib/python3.12/site-packages/asyncpg/connection.py:2731mcp-python-archive-extract-unconfined (critical/medium)
An archive is extracted without validating member paths. A tar or zip entry may name `../` or an absolute path and write outside the destination; Python's extractall has historically done exactly that.
```
    frame = sys._getframe().f_back
    try:
        stack = traceback.StackSummary.extract(
            traceback.walk_stack(frame), lookup_lines=False)
    finally:
```
packages/engine/.venv312/lib/python3.12/site-packages/coverage/execfile.py:213mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
        cwd = os.getcwd()
        try:
            exec(code, main_mod.__dict__)
        except SystemExit:  # pylint: disable=try-except-raise
            # The user called sys.exit().  Just pass it along to the upper
```
packages/engine/.venv312/lib/python3.12/site-packages/coverage/parser.py:589mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
        case ast.Name():
            if node.id in ["True", "False", "None", "__debug__"]:
                return True, eval(node.id)  # pylint: disable=eval-used
        case ast.UnaryOp():
            if isinstance(node.op, ast.Not):
```
packages/engine/.venv312/lib/python3.12/site-packages/coverage/templite.py:74mcp-python-eval-exec-nonliteral (critical/medium)
eval/exec is called on a value that is not a literal. If any component is caller-supplied this is direct code execution in the server's process.
```
        # Execute the source, defining globals, and return them.
        global_namespace: dict[str, Any] = {}
        exec(python_source, global_namespace)
        return global_namespace
```
packages/engine/.venv312/lib/python3.12/site-packages/dateutil/zoneinfo/rebuild.py:24mcp-python-archive-extract-unconfined (critical/medium)
An archive is extracted without validating member paths. A tar or zip entry may name `../` or an absolute path and write outside the destination; Python's extractall has historically done exactly that.
```
        with TarFile.open(filename) as tf:
            for name in zonegroups:
                tf.extract(name, tmpdir)
            filepaths = [os.path.join(tmpdir, n) for n in zonegroups]
```

packages/engine/.venv312/lib/python3.12/site-packages/mako/codegen.py:117mcp-python-eval-exec-nonliteral (critical/medium)