feat: refresh shared skills catalog

This commit is contained in:
vasily committed 2026-10-30 12:40:16 +08:00
1 parent 98bb35e6fb
commit 418792d1ec
49 files changed
+2273 -2390

No files matched your search

+30 -90
View File
@@ -1,98 +1,38 @@
---
name: app-security
description: >
Full-stack application and API security hardening: Four-Pillar upload defense,
SSRF prevention, input boundary clamping, IDOR elimination, and secret masking.
Use when creating or auditing API routes, handling uploads, making outbound requests,
or preparing pre-release security verification.
concerns: [security]
Harden affected application boundaries when implementing or auditing authorization, uploads, user-influenced outbound requests, or sensitive data handling.
scope: global
---
# Application Security Hardening
# Application security
Enforces defensive boundaries across the API membrane, eliminating exploit vectors, path traversals, SSRF risks, IDOR vulnerabilities, and payload exhaustion.
Inspect the affected boundary and existing controls. Apply the protections relevant
to the task; a small fix does not require a full application audit.
```mermaid
flowchart LR
A["Inbound Request"] --> B["1. Membrane Clamping<br/>(Schema & Bound Validation)"]
B --> C["2. Four-Pillar Uploads<br/>(Size, Ext, Magic, Path)"]
C --> D["3. Outbound SSRF Guard<br/>(Loopback/Metadata Block)"]
D --> E["4. Secret Masking<br/>(Zero Token Sediment)"]
```
1. Validate untrusted payloads with runtime schemas and resource bounds derived
from product requirements. Reject invalid data; do not silently truncate credentials.
2. Derive identity from verified server authentication. Enforce tenant/resource
permissions on private reads and writes, preferably within the data operation.
Cover unauthenticated access, cross-tenant access, and relevant races.
3. For uploads, enforce a product-specific extension/type allowlist, stream byte
limits, and appropriate content validation. Magic headers alone do not prove
safety. Use generated storage names and an isolated non-executable root; prevent
traversal and symlink escapes. Serve potentially active content with appropriate
isolation and headers. Bound archive expansion or decoding work when applicable.
4. For user-influenced outbound destinations, allowlist known services where possible.
Parse URLs, restrict schemes, resolve and validate all IPv4/IPv6 addresses, and
prevent DNS changes from bypassing connection checks. Disable redirects or validate
each destination using the same policy. Block private, loopback, link-local,
unspecified, and metadata targets unless a specific trusted internal service is
intentionally allowed. Apply time, response-size, and network egress limits.
5. Redact credentials at logging/telemetry boundaries and keep public errors free
of secrets and internal traces. Apply relevant session, CSRF, rate-limiting, and
browser content controls using existing framework facilities.
6. Verify the changed boundary with meaningful negative cases under
[shared verification](../../protocols/workflow.md#verification). Report actual
protections and gaps; do not claim the whole app is secure from a checklist.
---
## Phase 0: Setup and Protocols
1. Review reference playbooks:
- [references/app-hardening-playbook.md](references/app-hardening-playbook.md) for concrete TypeScript/Python code patterns and boundary clamps.
- [references/review-checklist.md](references/review-checklist.md) for pre-release OWASP verification checks.
2. Invariants:
- Every input payload must be typed and bounded.
- Every state mutation must verify session identity and tenant ownership.
- Outbound HTTP fetches must never touch private/loopback networks.
---
## Phase 1: Ingest and Check
1. **Surface Identification**:
- Inbound API routes (REST, GraphQL, RPC handlers).
- File/document ingestion and attachment endpoints.
- Outbound network calls (webhooks, URL unfurlers, external data scrapers).
- Data persistence operations and logging sinks.
2. **Access Control Check**:
- Confirm identity is derived from verified server sessions/tokens, never trusted client parameters (`userId`, `orgId`).
- Confirm entity queries enforce ownership: verify record exists AND belongs to the authenticated caller before mutating.
---
## Phase 2: Processing (Core Logic)
### Step 1: Input Boundaries & Membrane Clamping
- Never accept arbitrary, unvalidated request dictionaries. Model all payloads using strict schemas (e.g. Pydantic, Zod).
- Enforce hard string limits:
- Text prompts / message content: Max 50,000 characters.
- Titles / Names: Max 100–200 characters.
- Pagination limits: Clamped to `1 <= limit <= 50`.
- Batch arrays: Clamped to max 100–200 items.
- Sanitize entity and path identifiers against path traversal tokens (`../`, `..\\`).
### Step 2: Four-Pillar Upload Defense
When handling file or media uploads:
1. **Size Bounds**: Reject payloads exceeding size thresholds (e.g., 100MB for docs; 5MB for images).
2. **Blocked Extensions**: Reject executable and script formats (`.exe`, `.bat`, `.sh`, `.svg`, `.html`, `.php`).
3. **Magic Byte Inspection**: Inspect file headers to detect disguised binaries (PE `MZ`, ELF, Mach-O).
4. **Path Traversal Defense**:
- Sanitize original filenames (strip path separators and non-printable characters).
- Write files strictly to designated, isolated upload roots with unique IDs (e.g. UUID filenames).
### Step 3: Outbound SSRF Guard
Before executing outbound HTTP requests (scraping, webhooks):
- Validate target URLs against an allowlist or safety filter.
- Block loopback addresses (`127.0.0.1`, `localhost`, `::1`), RFC 1918 private subnets (`10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`), and cloud metadata services (`169.254.169.254`).
- Restrict allowed protocols strictly to `http` and `https`.
### Step 4: Secret Masking & Error Shielding
- Scrub Authorization tokens (`Bearer ***`), provider API keys, and sensitive credentials from logs, database traces, and telemetry.
- In public HTTP error responses, return clean structured error objects with opaque error codes; never leak internal filesystem paths, environment variables, or stack traces.
---
## Phase 3: The System One Balance Pass
- **Augment, Don't Handcuff**:
- Do NOT break local development workflows: allow local mock endpoints and fixture testing in non-production test environments.
- Keep security checks non-intrusive during prototyping; enforce strictly at boundaries and pre-release gates.
- Avoid noisy confirmation warnings for routine safe operations.
---
## Phase 4: Output Execution & Verification
1. Run verification checks from [references/review-checklist.md](references/review-checklist.md).
2. Provide a security verification summary detailing:
- Bound clamps applied to route schemas.
- Upload filters active (size, extension, magic bytes, safe path).
- SSRF protection status on outbound calls.
- Secret scrubbing confirmation.
Use [the playbook](references/app-hardening-playbook.md) for implementation choices
and [the checklist](references/review-checklist.md) for an explicitly requested audit.
Local fixtures need deliberate configuration, not an automatic security bypass.