hackscan 0.1.0__tar.gz → 0.2.0__tar.gz

{hackscan-0.1.0 → hackscan-0.2.0}/.gitignore

@@ -11,3 +11,7 @@ htmlcov/
 *.sarif
 !tests/fixtures/**/*.sarif
 .hackscan-cache/
+
+# Local tool caches/sandbox scratch (never packaged)
+.uv-cache/
+.test-tmp/

{hackscan-0.1.0 → hackscan-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hackscan
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python SAST orchestrator: own AST + taint engine, imports Semgrep/Bandit/CodeQL/Gitleaks, dedupes, emits SARIF.
 Project-URL: Source, https://github.com/kahledawad2019-netizen/hackscan
 Project-URL: Issues, https://github.com/kahledawad2019-netizen/hackscan/issues
@@ -21,6 +21,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1
 Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=13.7
 Description-Content-Type: text/markdown
 
 # HackScan
@@ -47,6 +48,8 @@ HIGH     confirmed  views.py:10:9  HS-SQLI-001  [100%]
 | **Sound suppression** | A finding is only dismissed if *every* path is safe. Branches, loops (`break`/`continue`), `try`/`except`/`finally`, aliasing and mutation of lists/dicts, closures and `:=` are modeled. A differential fuzzer executes thousands of random programs to check that no dismissed sink ever receives attacker input. |
 | **Framework-aware** | Sources: Flask `request.*`, Django/DRF/Starlette/FastAPI request objects (incl. `self.request`), route-handler parameters, `input()`, `sys.argv`. |
 | **One report from many tools** | Imports Semgrep, Bandit, CodeQL (SARIF) and Gitleaks; deduplicates by vulnerability class and location, keeping every tool as provenance. |
+| **Fixes you can apply** | Mechanical, validated fix suggestions: parameterized queries (driver-aware placeholders), argument lists instead of shell strings, `ast.literal_eval`, SHA-256. Each is an exact edit that re-parses; ambiguous cases get no fix rather than a wrong one. |
+| **Optional local-LLM triage** | `--llm` asks a local Ollama model about remaining candidates. It can confirm, but may only suppress by citing a line that HackScan verifies itself (an allow-list guard, constant or sanitizer that holds on every path). Code is treated as untrusted data; secrets are redacted. |
 | **CI-ready** | SARIF 2.1.0 (validated against the OASIS schema) for GitHub code scanning, `--fail-on` exit codes, stable fingerprints that survive code moves. |
 
 ## Install
@@ -55,7 +58,7 @@ HIGH     confirmed  views.py:10:9  HS-SQLI-001  [100%]
 pip install hackscan        # or: uv tool install hackscan / pipx install hackscan
 ```
 
-Python 3.10–3.13, any OS. No network access and no LLM needed.
+Python 3.10–3.13, any OS. No network access and no LLM needed (`--llm` is opt-in).
 
 ## Usage
 
@@ -66,6 +69,8 @@ hackscan scan . --fail-on high                    # exit 1 on open high/critical
 hackscan scan . --format json --show-suppressed   # everything, machine-readable
 hackscan scan . --with bandit,semgrep,gitleaks    # also run these tools if installed
 hackscan scan . --import codeql=results.sarif     # merge a report you already have
+hackscan scan . --show-fixes                      # include fix suggestions as diffs
+hackscan scan . --llm --model qwen2.5-coder:7b    # triage candidates with local Ollama
 hackscan rules                                    # list rules
 ```
 
@@ -79,6 +84,10 @@ hackscan rules                                    # list rules
 | `--plugins DIR` | Load custom rules (see below). |
 | `--allow-incomplete` | Do not exit 2 when some files cannot be analyzed (they are still listed). |
 | `--no-taint` | Pattern matching only. |
+| `--show-fixes` / `--no-fix` | Print suggested fixes as diffs / do not generate fixes (fixes are also in JSON and SARIF `fixes`). |
+| `--llm`, `--model`, `--ollama-host` | Opt-in LLM triage of candidates via Ollama (default `http://localhost:11434`). |
+| `--llm-max`, `--llm-timeout`, `--llm-no-suppress` | LLM budget (default 20 findings, 60 s/request); let the LLM confirm/annotate but never suppress. |
+| `--color auto\|always\|never` | Rich terminal output; `auto` uses it only on an interactive terminal (not in CI, pipes or with `NO_COLOR`). |
 | `--jobs N` | Worker processes (default: automatic). |
 
 Exit codes: `0` OK, `1` `--fail-on` threshold reached, `2` usage/config/plugin error or
@@ -101,8 +110,35 @@ with: [bandit]
 import:
   codeql: codeql-results.sarif
 plugins: security/rules
+llm: false
+llm-model: qwen2.5-coder:7b
 ```
 
+### LLM triage
+
+`--llm` sends each remaining *candidate* (never confirmed or suppressed findings) with
+its surrounding function to a local Ollama model and asks for a verdict:
+
+- **true positive**: the finding becomes *confirmed* (+15 confidence); a suggested fix is
+  kept only if the patched file parses and a re-scan shows the finding gone and nothing new.
+- **false positive**: only accepted if the model cites a line that HackScan verifies runs
+  on every path and makes the value safe: an allow-list guard (`if x not in {...}: return`,
+  `if not x.isdigit(): raise`, or `if not x.isdecimal(): raise`), a constant, or a
+  class-appropriate sanitizer. `isnumeric()`, `isalnum()`, `isalpha()`, and
+  `isidentifier()` do not qualify. Otherwise the reasoning is attached as a note and
+  the finding stays open.
+- Code is fenced with a random per-request token and treated as untrusted data; replies
+  must match a JSON schema; secret-looking values are redacted; answers are cached.
+
+Use a non-reasoning instruct or coder model. Measured on a CPU-only laptop (~30 s per
+finding): `qwen3:4b-instruct-2507` judged a real injection, a bypassable length check and
+an allow-list guard correctly; `qwen2.5-coder:3b` never suppressed but also missed the
+allow-list guard (larger models do better). Reasoning models such as `deepseek-r1` often
+spend their whole output budget thinking, which HackScan reports as "no answer" and
+leaves the finding open. In the same test both small models obeyed a comment in the
+scanned code telling them to answer "false positive"; the deterministic evidence check
+rejected it and the finding stayed open. That check, not the model, decides suppression.
+
 ### Suppressing a finding
 
 ```python
@@ -165,6 +201,22 @@ class PickleLoads(RulePlugin):
 - Taint analysis is intra-procedural: values arriving through function parameters are
   candidates, not confirmations (inter-procedural analysis is on the roadmap).
 - Python only. Imported tools may cover other languages; their findings are passed through.
+- Fix suggestions are deliberately conservative: many vulnerable lines get none. Command
+  fixes (argument lists) are only offered for programs whose arguments are inert data
+  (`cat`, `ls`, `grep`, `head`, ...): many others run operands or options as
+  commands (`sh -c`, `npx PKG`, `git -c alias=!cmd`, `tar --to-command`). They are also
+  not offered when a value directly follows a flag; put `--` before operands to get one.
+  A value starting with `-` can still be read as an option, so review command fixes. No
+  fix is offered for a call that contains a secret, or for SQL containing comments.
+- SQL fixes are not offered for unquoted values inside parentheses, double-quoted
+  identifiers, or SQL text containing backslashes, `$`, backticks or brackets;
+  redaction of values that coincide with identifiers or tool metadata is best-effort.
+- String and bytes literals assigned to secret-looking names (`api_key`, `password`, `token`, ...)
+  are masked in snippets, the LLM context and fix diffs. Their values are also removed
+  from imported messages and evidence before output or LLM triage when the value is
+  secret-like (at least eight characters with a digit or symbol, or at least sixteen
+  characters). Known secrets in proposed fixes cause the fix to be omitted. Imported
+  findings for files that cannot be parsed have no source snippet.
 
 ## Development
 

{hackscan-0.1.0 → hackscan-0.2.0}/PROJECT.md

@@ -140,8 +140,8 @@ mature scanners, (3) taint-based confirmation, (4) optional local-LLM triage and
 | M0 ✅ | Skeleton & contracts | Repo, `pyproject`, CI (ruff + pytest on 3.10–3.13), `Finding` models, fixture corpus layout; **frozen** `Finding` schema v1, `taxonomy.py`, fingerprint + dedupe/merge implemented with order-independence tests; importer contract (above) documented | — |
 | M1 ✅ | AST engine & rules | Rules 1–2 pass per-rule vulnerable **and** safe fixtures | M0 |
 | M2 ✅ | Taint | Framework fixtures (Flask/Django/FastAPI); constant/sanitized flows suppressed; tests for taint boundaries | M1 |
-| M3 🔨 | CLI, SARIF, importers → **v0.1.0 on PyPI** (built; publish pending) | `pip install hackscan` works on clean venv; SARIF validates against official schema; `--fail-on` exit codes tested | M2 |
-| M4 | LLM + remediation + TUI → v0.2.0 | All LLM tests run against a mocked Ollama; offline degradation tested; prompt-injection fixture | M3 |
+| M3 ✅ | CLI, SARIF, importers → **v0.1.0 on PyPI** (released 2026-10-08) | `pip install hackscan` works on clean venv; SARIF validates against official schema; `--fail-on` exit codes tested | M2 |
+| M4 ✅ | LLM + remediation + TUI → **v0.2.0** (2026-10-09; 14 Codex gate rounds, double-OK) | All LLM tests run against a mocked Ollama; offline degradation tested; prompt-injection fixture | M3 |
 | M5 | Inter-procedural taint, benchmark, GitHub Action → v0.3.0 | Benchmark report in README; Action used on the repo itself | M4 |
 
 ## Test Strategy
@@ -270,3 +270,91 @@ hackscan/
   known secrets scrubbed from warnings/errors; `-o` only overwrites previous HackScan
   reports; failed `--import` reports make the scan incomplete (exit 2); `--with` tools
   exiting with an error code are `partial` (warning, fails `--strict-tools`).
+- 2026-10-09 (M4a/M4b): template fixes (parameterized SQL with driver-specific placeholders,
+  argv lists instead of shell strings, `ast.literal_eval`, SHA-256) as validated exact edits;
+  `--no-fix`, `--show-fixes`. LLM triage is **opt-in** (`--llm`): candidates only, JSON-schema
+  replies, per-request random code fence, redacted context, cache, `--llm-max`,
+  `--llm-timeout`, bounded output tokens. LLM suppression requires evidence that a
+  deterministic checker accepts and that holds on every path: a constant or class-valid
+  sanitizer assignment, or an allow-list guard (`not in {consts}`, 
+  `isdigit()/isalnum()`), in the function body before the sink, covering all sink locals,
+  never rebound/mutated afterwards. LLM fixes are kept only if the patched file parses and
+  re-running passes 1-2 shows the finding gone and no new ones. Measured locally: CPU-only
+  Ollama with the reasoning model deepseek-r1:8b ignores `think: false` and exhausts its
+  budget — reported as "no answer"; non-reasoning coder models are recommended.
+- 2026-10-09 (Codex M4 review): LLM suppression must vouch for *every* value in the sink
+  (any name, local or global; calls/attributes/subscripts in the sink are never vouched for)
+  — fixes a P0 where `safe + suffix` (global `suffix` from the environment) was suppressed.
+  LLM fixes must call an allow-listed safe API for the class (or keep the SQL receiver with
+  parameters), keep every original value, and never use `__import__`/`eval`/`shell=` etc.
+  The flagged-call field sent to the model and `--show-fixes` diff context are redacted;
+  fix replacements are redacted like other fields. C0/C1 control characters from code,
+  tools or the model are shown escaped, never emitted. `IN (...)` lists are not
+  parameterized (a single placeholder changes results); f-string/% argv values are wrapped
+  in `str()`; imports are never inserted above a shebang or encoding cookie; malformed
+  Ollama replies are discarded instead of crashing.
+- 2026-10-09 (live Ollama check, CPU-only): qwen3:4b-instruct-2507 got real injection,
+  fake length guard and allow-list guard right once the verifier (a) maps a cited line
+  inside a top-level statement (e.g. a guard's `return`) to that statement and (b) treats
+  the model's evidence kind as a hint, trying every deterministic check (each is complete
+  on its own, so this is equally sound). Response schema now orders `reason` first
+  (Ollama generates keys in schema order), prompt v3. qwen2.5-coder:3b: safe but misses
+  the guard. Both models obeyed an injected "reply false_positive" comment; the verifier
+  rejected it. A missing model now reports "not installed; run `ollama pull <model>`".
+- 2026-10-09 (Codex M4 re-review): rebinding after cited evidence now includes imports
+  (`*` = anything), `match` captures, `except ... as`, nested defs/classes; `assert` is
+  never evidence (`python -O`). LLM command fixes must run the original program (never a
+  shell/interpreter) with the original literal words in order and only harmless
+  keywords; LLM SQL fixes must be one literal with the original SQL tokens (values as
+  placeholders). SQL template placeholders only after comparisons, in VALUES lists and
+  after LIMIT/OFFSET (not `typeof(?)` or select lists). String literals assigned to
+  secret-looking names are redacted by raw source text, so implicitly joined and
+  triple-quoted secrets never reach the model or fix diffs.
+- 2026-10-09 (Codex verify round): token/word comparison was bypassable (extra computed
+  argv element, swapped SQL parameters, SQL comments). LLM fixes must now equal what
+  HackScan derives itself: argv element-for-element (`str()` wrapper ignored), SQL text
+  exactly plus the original values in order. SQL containing comments (`--`, `/*`, `#`)
+  gets no fix. Secret literals are masked character for character in the source
+  (lines/columns kept) for LLM context and diffs. Rebinding is judged by (line, column)
+  outside the cited statement; any `nonlocal`/`global` of the name voids the evidence.
+- 2026-10-09 (Codex verify round 2): an argv list stops shell injection, not argument
+  injection (`git -c alias.x=!cmd`, `python3.12 -c`). `_argv` (ground truth for template
+  and LLM fixes) now refuses interpreters/wrappers (versioned and `.exe` names included)
+  and any value directly after a flag other than `--`. LLM SQL fixes must use the
+  placeholder of the detected driver (none or ambiguous: no fix). Snippets and sinks of
+  own findings and imported ones come from masked source; a call containing a secret
+  literal gets no fix (a fix must carry the real code); diffs mask both sides from
+  their own syntax trees. Masking also covers walrus and unpacking targets.
+- 2026-10-09 (stop-time review + Codex verify round 3): the interpreter denylist could
+  never be complete (`npx PKG`, `tar --to-command`, `find -exec`...), so argv fixes now
+  use an allowlist of programs with inert arguments (`INERT_PROGRAMS`: echo, cat, ls,
+  grep, head...; `.bat`/`.cmd` never match). Masking covers `for`/comprehension/`with`
+  targets; for parsed Python files the snippet always comes from masked source (a tool's
+  SARIF snippet only as a fallback, redacted); LLM evidence quotes masked source. Round 3
+  confirmed all earlier fixes and found no regressions (fingerprints, dedupe, pool).
+- 2026-10-09 (security follow-up): LLM allow-list guards require class-safe string or integer
+  constants; source secret literal values now redact imported messages and evidence before
+  output and LLM triage; fallback snippets from unparseable files redact literals and
+  assigned values; `echo` and `dir` no longer get shell-less command fixes because they
+  are Windows cmd.exe builtins.
+- 2026-10-09 (release gate): SQL LIMIT allow-list values cannot contain commas; template
+  and LLM fixes containing a known secret are dropped before export. Imported findings
+  have no snippet unless their Python source parses, preventing multi-line secret leaks.
+  Equal-length secrets are redacted in lexical order, and only secret-like source values
+  join report-wide known secrets; local source masking still covers every secret-named literal.
+- 2026-10-09 (gate review follow-up): LLM predicate guard evidence is limited to
+  `isdigit()` and `isdecimal()`; constant allow-lists retain their existing rule.
+  Secret-named function and lambda defaults are masked, and AST rule messages and evidence
+  use the file's masked literal spans. Gitleaks values are redacted at any nonzero length
+  across findings, warnings and errors. Diff redaction preserves assignment spacing.
+  Every masked source literal of at least four characters is also redacted within findings,
+  fixes and LLM requests for its own file. LLM rewrites now require exact code and hash
+  arguments and literal subprocess keyword values to prevent hidden execution. Release-gate
+  fixes restrict shell template keywords, redact secret-bearing rule IDs and escaped source
+  spellings, and refuse SQL placeholders inside partial quoted literals. Sole dynamic
+  parenthesized SQL lists get no placeholder; file-scoped secrets also redact rule metadata
+  before triage and diagnostics across the report. Release-gate follow-up refuses unquoted
+  dynamic SQL values inside any parentheses and SQL text containing backslashes, while
+  redacting finding function names before IDs, output and triage. Double-quoted SQL
+  identifiers and SQL text containing `$` also receive no fix. Numeric and concatenated
+  secret literals are masked and collected.

{hackscan-0.1.0 → hackscan-0.2.0}/README.md

@@ -22,6 +22,8 @@ HIGH     confirmed  views.py:10:9  HS-SQLI-001  [100%]
 | **Sound suppression** | A finding is only dismissed if *every* path is safe. Branches, loops (`break`/`continue`), `try`/`except`/`finally`, aliasing and mutation of lists/dicts, closures and `:=` are modeled. A differential fuzzer executes thousands of random programs to check that no dismissed sink ever receives attacker input. |
 | **Framework-aware** | Sources: Flask `request.*`, Django/DRF/Starlette/FastAPI request objects (incl. `self.request`), route-handler parameters, `input()`, `sys.argv`. |
 | **One report from many tools** | Imports Semgrep, Bandit, CodeQL (SARIF) and Gitleaks; deduplicates by vulnerability class and location, keeping every tool as provenance. |
+| **Fixes you can apply** | Mechanical, validated fix suggestions: parameterized queries (driver-aware placeholders), argument lists instead of shell strings, `ast.literal_eval`, SHA-256. Each is an exact edit that re-parses; ambiguous cases get no fix rather than a wrong one. |
+| **Optional local-LLM triage** | `--llm` asks a local Ollama model about remaining candidates. It can confirm, but may only suppress by citing a line that HackScan verifies itself (an allow-list guard, constant or sanitizer that holds on every path). Code is treated as untrusted data; secrets are redacted. |
 | **CI-ready** | SARIF 2.1.0 (validated against the OASIS schema) for GitHub code scanning, `--fail-on` exit codes, stable fingerprints that survive code moves. |
 
 ## Install
@@ -30,7 +32,7 @@ HIGH     confirmed  views.py:10:9  HS-SQLI-001  [100%]
 pip install hackscan        # or: uv tool install hackscan / pipx install hackscan
 ```
 
-Python 3.10–3.13, any OS. No network access and no LLM needed.
+Python 3.10–3.13, any OS. No network access and no LLM needed (`--llm` is opt-in).
 
 ## Usage
 
@@ -41,6 +43,8 @@ hackscan scan . --fail-on high                    # exit 1 on open high/critical
 hackscan scan . --format json --show-suppressed   # everything, machine-readable
 hackscan scan . --with bandit,semgrep,gitleaks    # also run these tools if installed
 hackscan scan . --import codeql=results.sarif     # merge a report you already have
+hackscan scan . --show-fixes                      # include fix suggestions as diffs
+hackscan scan . --llm --model qwen2.5-coder:7b    # triage candidates with local Ollama
 hackscan rules                                    # list rules
 ```
 
@@ -54,6 +58,10 @@ hackscan rules                                    # list rules
 | `--plugins DIR` | Load custom rules (see below). |
 | `--allow-incomplete` | Do not exit 2 when some files cannot be analyzed (they are still listed). |
 | `--no-taint` | Pattern matching only. |
+| `--show-fixes` / `--no-fix` | Print suggested fixes as diffs / do not generate fixes (fixes are also in JSON and SARIF `fixes`). |
+| `--llm`, `--model`, `--ollama-host` | Opt-in LLM triage of candidates via Ollama (default `http://localhost:11434`). |
+| `--llm-max`, `--llm-timeout`, `--llm-no-suppress` | LLM budget (default 20 findings, 60 s/request); let the LLM confirm/annotate but never suppress. |
+| `--color auto\|always\|never` | Rich terminal output; `auto` uses it only on an interactive terminal (not in CI, pipes or with `NO_COLOR`). |
 | `--jobs N` | Worker processes (default: automatic). |
 
 Exit codes: `0` OK, `1` `--fail-on` threshold reached, `2` usage/config/plugin error or
@@ -76,8 +84,35 @@ with: [bandit]
 import:
   codeql: codeql-results.sarif
 plugins: security/rules
+llm: false
+llm-model: qwen2.5-coder:7b
 ```
 
+### LLM triage
+
+`--llm` sends each remaining *candidate* (never confirmed or suppressed findings) with
+its surrounding function to a local Ollama model and asks for a verdict:
+
+- **true positive**: the finding becomes *confirmed* (+15 confidence); a suggested fix is
+  kept only if the patched file parses and a re-scan shows the finding gone and nothing new.
+- **false positive**: only accepted if the model cites a line that HackScan verifies runs
+  on every path and makes the value safe: an allow-list guard (`if x not in {...}: return`,
+  `if not x.isdigit(): raise`, or `if not x.isdecimal(): raise`), a constant, or a
+  class-appropriate sanitizer. `isnumeric()`, `isalnum()`, `isalpha()`, and
+  `isidentifier()` do not qualify. Otherwise the reasoning is attached as a note and
+  the finding stays open.
+- Code is fenced with a random per-request token and treated as untrusted data; replies
+  must match a JSON schema; secret-looking values are redacted; answers are cached.
+
+Use a non-reasoning instruct or coder model. Measured on a CPU-only laptop (~30 s per
+finding): `qwen3:4b-instruct-2507` judged a real injection, a bypassable length check and
+an allow-list guard correctly; `qwen2.5-coder:3b` never suppressed but also missed the
+allow-list guard (larger models do better). Reasoning models such as `deepseek-r1` often
+spend their whole output budget thinking, which HackScan reports as "no answer" and
+leaves the finding open. In the same test both small models obeyed a comment in the
+scanned code telling them to answer "false positive"; the deterministic evidence check
+rejected it and the finding stayed open. That check, not the model, decides suppression.
+
 ### Suppressing a finding
 
 ```python
@@ -140,6 +175,22 @@ class PickleLoads(RulePlugin):
 - Taint analysis is intra-procedural: values arriving through function parameters are
   candidates, not confirmations (inter-procedural analysis is on the roadmap).
 - Python only. Imported tools may cover other languages; their findings are passed through.
+- Fix suggestions are deliberately conservative: many vulnerable lines get none. Command
+  fixes (argument lists) are only offered for programs whose arguments are inert data
+  (`cat`, `ls`, `grep`, `head`, ...): many others run operands or options as
+  commands (`sh -c`, `npx PKG`, `git -c alias=!cmd`, `tar --to-command`). They are also
+  not offered when a value directly follows a flag; put `--` before operands to get one.
+  A value starting with `-` can still be read as an option, so review command fixes. No
+  fix is offered for a call that contains a secret, or for SQL containing comments.
+- SQL fixes are not offered for unquoted values inside parentheses, double-quoted
+  identifiers, or SQL text containing backslashes, `$`, backticks or brackets;
+  redaction of values that coincide with identifiers or tool metadata is best-effort.
+- String and bytes literals assigned to secret-looking names (`api_key`, `password`, `token`, ...)
+  are masked in snippets, the LLM context and fix diffs. Their values are also removed
+  from imported messages and evidence before output or LLM triage when the value is
+  secret-like (at least eight characters with a digit or symbol, or at least sixteen
+  characters). Known secrets in proposed fixes cause the fix to be omitted. Imported
+  findings for files that cannot be parsed have no source snippet.
 
 ## Development
 

{hackscan-0.1.0 → hackscan-0.2.0}/pyproject.toml

@@ -14,6 +14,7 @@ requires-python = ">=3.10"
 dependencies = [
     "click>=8.1",
     "pyyaml>=6.0.3",
+    "rich>=13.7",
 ]
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -60,3 +61,9 @@ path = "src/hackscan/__init__.py"
 [project.urls]
 Source = "https://github.com/kahledawad2019-netizen/hackscan"
 Issues = "https://github.com/kahledawad2019-netizen/hackscan/issues"
+
+[tool.ruff.lint.per-file-ignores]
+# Inline code samples under test are clearer unwrapped.
+"tests/test_remediate.py" = ["E501"]
+"tests/test_llm.py" = ["E501"]
+"tests/test_ui.py" = ["E501"]

{hackscan-0.1.0 → hackscan-0.2.0}/src/hackscan/__init__.py

@@ -1,3 +1,3 @@
 """HackScan: Python SAST orchestrator and verifier."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{hackscan-0.1.0 → hackscan-0.2.0}/src/hackscan/analyzers/ast_pass.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from hackscan.analyzers.suppressions import apply_inline_suppressions
 from hackscan.analyzers.taint_pass import apply_taint
 from hackscan.core.models import OWN_SOURCE, Evidence, Finding, Region
+from hackscan.core.redact import file_secret_literal_values, secret_literal_values
 from hackscan.core.taxonomy import classify
 from hackscan.plugins.base import FileContext, Match, RulePlugin
 
@@ -24,6 +25,8 @@ class FileResult:
     path: str
     findings: list[Finding] = field(default_factory=list)
     errors: list[str] = field(default_factory=list)
+    secrets: set[str] = field(default_factory=set)
+    file_secrets: set[str] = field(default_factory=set)
 
 
 def analyze_source(
@@ -40,6 +43,8 @@ def analyze_source(
         result.errors.append(f"{rel_path}: cannot parse: {exc}")
         return result
 
+    result.secrets = secret_literal_values(tree, source)
+    result.file_secrets = file_secret_literal_values(tree, source)
     ctx = FileContext(path=rel_path, source=source, tree=tree)
     by_type: dict[type[ast.AST], list[RulePlugin]] = {}
     for plugin in plugins:
@@ -109,26 +114,27 @@ def _to_finding(
         ),
     )
     func = ctx.enclosing_function(node)
-    sink = ctx.segment(node)
+    sink = ctx.masked_segment(node)  # secrets never enter a finding
+    message = ctx.redact_masked_spans(match.message)
     return Finding(
         id="",
         vuln_class=classify(plugin.rule_id, plugin.cwe),
         rule_id=plugin.rule_id,
         severity=plugin.severity,
         location=region,
-        message=match.message,
+        message=message,
         snippet=_line_snippet(ctx, start_line, end_line),
         sink=sink,
         function=qualnames.get(id(func)) if func is not None else None,
         cwe=plugin.cwe,
         sources=(OWN_SOURCE,),
         confidence=match.confidence if match.confidence is not None else plugin.default_confidence,
-        evidence=(Evidence(PRODUCER, "rule_match", f"{plugin.name}: {match.message}"),),
+        evidence=(Evidence(PRODUCER, "rule_match", f"{plugin.name}: {message}"),),
     )
 
 
 def _line_snippet(ctx: FileContext, start: int, end: int, max_lines: int = 5) -> str:
-    lines = ctx.lines[start - 1 : min(end, start + max_lines - 1)]
+    lines = ctx.masked_lines[start - 1 : min(end, start + max_lines - 1)]
     return "\n".join(lines)