Software and Data Integrity Failures

Analyze source code, CI/CD configurations, and dependency manifests for integrity violations. Detect insecure deserialization, unverified auto-updates, missing subresource integrity, CI/CD pipeline injection, and untrusted dependency sources. Produce actionable findings with severity ratings, code locations, and concrete remediation steps.

Supported Flags

All flags from ../../shared/schemas/flags.md are supported:

Flag Relevant Behavior

--scope <value>

Determines which files to analyze (default: changed )

--depth <value>

quick : pattern scan only. standard : full read + analysis. deep : trace data flows and dependency chains cross-file. expert : red team simulation with DREAD scoring

--severity <value>

Filter findings by minimum severity

--format <value>

Output format: text , json , sarif , md

--fix

Chain into remediation after analysis

--quiet

Findings only, no explanations

--explain

Add learning context to each finding

Framework Context

OWASP Top 10 2021 - A08: Software and Data Integrity Failures

Code and infrastructure that does not protect against integrity violations. This category covers a broad set of concerns around trusting the provenance and authenticity of software, data, and infrastructure:

• Relying on plugins, libraries, or modules from untrusted sources, repositories, or CDNs

• Insecure CI/CD pipelines that allow unauthorized code or configuration changes

• Auto-update functionality that downloads and applies updates without integrity verification

• Insecure deserialization where untrusted data is deserialized into objects, enabling remote code execution, replay attacks, injection, or privilege escalation

STRIDE Mapping: Tampering, Elevation of Privilege

CWE References: CWE-502 (Deserialization of Untrusted Data), CWE-829 (Inclusion of Functionality from Untrusted Control Sphere), CWE-494 (Download of Code Without Integrity Check), CWE-915 (Improperly Controlled Modification of Dynamically-Determined Object Attributes), CWE-353 (Missing Support for Integrity Check)

Detection Patterns

Read references/detection-patterns.md before performing analysis. It contains detailed Grep heuristics, language-specific code examples, scanner coverage, and false positive guidance for each vulnerability pattern.

Workflow

1. Determine Scope

Parse --scope flag and resolve to a concrete file list:

• Apply scope resolution per ../../shared/schemas/flags.md .

• Filter to files relevant to integrity:

• Serialization/deserialization code (data processing, API handlers)

• CI/CD configuration files (.github/workflows/*.yml , .gitlab-ci.yml , Jenkinsfile , .circleci/config.yml , azure-pipelines.yml , bitbucket-pipelines.yml )

• Dependency manifests and lockfiles (package.json , package-lock.json , yarn.lock , requirements.txt , Pipfile.lock , go.sum , Cargo.lock , pom.xml , build.gradle )

• HTML files with CDN script/link tags

• Update/installer scripts and auto-update mechanisms

• Pre/post-install hooks in package configurations

• Dockerfile and container build configurations

• Include infrastructure-as-code files that reference external resources or images.

2. Check for Scanners

Detect available scanners in order of preference:

Scanner Detect Relevant Rules

semgrep which semgrep

Insecure deserialization, unsafe YAML/pickle loading

trivy which trivy

Dependency vulnerabilities, misconfigurations, secret detection

osv-scanner which osv-scanner

Known vulnerabilities in dependencies across ecosystems

checkov which checkov

CI/CD misconfigurations, IaC integrity issues

bandit which bandit

Python-specific: pickle, yaml, marshal (B301, B506)

If no scanner is available, proceed with Claude analysis using Grep patterns from references/detection-patterns.md . Note in output: "No scanner available -- findings based on code pattern analysis only."

3. Run Scanners

For each available scanner:

• Execute against the scoped file list.

• Parse JSON output.

• Filter to integrity-related rules only.

• Normalize findings to the schema in ../../shared/schemas/findings.md .

• Set scanner.confirmed: true for scanner-detected findings.

4. Claude Analysis

Regardless of scanner availability, perform manual code analysis:

• Read references/detection-patterns.md for the full pattern catalog.

• Use Grep with the regex patterns to locate suspicious constructs.

• Read surrounding code context (30-50 lines) to assess each match.

• Trace data flows from untrusted sources to deserialization sinks.

• At --depth deep or higher: follow imports, trace dependency chains, analyze CI/CD workflow trigger conditions and secret exposure, map update mechanisms end-to-end.

• Deduplicate against scanner findings (same file + line = same finding).

• Set confidence: medium for Claude-only findings, confidence: high when confirmed by a scanner.

5. Report Findings

Format output per --format flag. Each finding uses the schema from ../../shared/schemas/findings.md with these specifics:

• ID prefix: INTEG (e.g., INTEG-001 , INTEG-002 )

• references.owasp: A08:2021

• references.stride: T (Tampering) or E (Elevation of Privilege)

• metadata.tool: integrity

• metadata.framework: owasp

• metadata.category: A08

Summary block (appended after all findings):

Summary

Scanners used: [list or "none"] Scanners missing: [list of recommended but unavailable] Top priorities: [top 3 findings to fix first and why]

What to Look For

These are the primary vulnerability patterns. See references/detection-patterns.md

for detailed regex patterns and code examples.

• Insecure deserialization -- Using pickle.loads , yaml.load (without SafeLoader), Java ObjectInputStream , or JSON.parse on untrusted input to reconstruct objects that can execute arbitrary code.

• CI/CD pipeline injection -- GitHub Actions or other CI workflows that interpolate untrusted input (PR titles, branch names, issue bodies) into run: blocks, enabling command injection in the build environment.

• CDN resources without SRI -- Loading JavaScript or CSS from third-party CDNs without integrity attributes, allowing a compromised CDN to inject malicious code.

• Auto-update without verification -- Download-and-execute update mechanisms that do not verify digital signatures or checksums before applying updates.

• Malicious pre/post-install scripts -- Package configurations with install hooks that execute arbitrary code during npm install , pip install , or similar commands.

• Missing lockfile integrity -- Dependency lockfiles absent from version control or containing no integrity hashes, allowing silent dependency substitution.

• Untrusted base images -- Dockerfiles using unverified or untagged base images (e.g., FROM node instead of FROM node:20-alpine@sha256:... ).

• Missing code signing -- Release artifacts, packages, or binaries distributed without digital signatures.

Scanner Integration

Refer to ../../shared/schemas/scanners.md for full scanner details.

Primary: trivy (dependency vulnerabilities, misconfigurations), osv-scanner (cross-ecosystem CVEs) Secondary: semgrep (deserialization patterns), bandit (Python pickle/YAML), checkov (CI/CD configs) Fallback: Grep-based pattern matching from references/detection-patterns.md plus Claude analysis of CI/CD configs and dependency manifests

When running as a subagent of the OWASP dispatcher, receive scope and flags from the parent agent prompt. Do not re-parse user input.

Output Format

All findings conform to the schema defined in ../../shared/schemas/findings.md .

ID prefix: INTEG (registered in the ID Prefix Registry as OWASP A08)

Example finding:

{ "id": "INTEG-001", "title": "Unsafe pickle deserialization of user-uploaded data", "severity": "critical", "confidence": "high", "location": { "file": "src/api/import_handler.py", "line": 72, "function": "import_data", "snippet": "data = pickle.loads(request.files['upload'].read())" }, "description": "User-uploaded file content is deserialized with pickle.loads, which can execute arbitrary Python code embedded in the pickle stream.", "impact": "An attacker can upload a crafted pickle file to achieve remote code execution on the server, potentially compromising the entire application and underlying infrastructure.", "fix": { "summary": "Replace pickle with a safe serialization format like JSON", "diff": "- data = pickle.loads(request.files['upload'].read())\n+ data = json.loads(request.files['upload'].read())" }, "references": { "cwe": "CWE-502", "owasp": "A08:2021", "stride": "T", "mitre_attck": "T1059" }, "scanner": { "name": "bandit", "rule": "B301", "confirmed": true }, "metadata": { "tool": "integrity", "framework": "owasp", "category": "A08" } }