application-security-pentesting
Production Application Security (AppSec) standards, OWASP Top 10 vulnerability remediation, SAST/DAST pipeline integration, secure code review, threat modeling, and defensive security posture.
- License 许可
- MIT
- 最近更新
- 2026-10-17
- Stars
- ★ 8
- Forks
- 1
01 前言 Front Matter
- name
- application-security-pentesting
- metadata
- { "category": "Cybersecurity and Penetration Testing" }
- description
- Production Application Security (AppSec) standards, OWASP Top 10 vulnerability remediation, SAST/DAST pipeline integration, secure code review, threat modeling, and defensive security posture.
- compatibility
- OWASP ZAP, Burp Suite, Semgrep, SonarQube, Python / Node.js / Go
03 SKILL.md 正文
Application Security & Penetration Testing Remediation
Overview
This skill provides standards and methodological frameworks for Application Security (AppSec) engineering, threat modeling, vulnerability assessment, and remediation of OWASP Top 10 vulnerabilities. It covers secure code review, static and dynamic analysis (SAST/DAST) integration, security headers configuration, and defensive controls.
1. Core Application Security Principles
- Defense-in-Depth Architecture: Never rely on a single defensive boundary. Enforce security controls at every application layer (Network, Gateway, Application Code, Database).
- Strict Input Sanitization & Parameterization: Treat all user inputs as untrusted. Enforce parameterized queries (Prepared Statements) for database access to eliminate SQL injection, and context-aware HTML encoding to prevent XSS.
- Principle of Least Privilege (PoLP): Grant minimum required API permissions, database permissions, and system rights to microservices and database users.
- Secure Authentication & Session Lifecycle: Enforce multi-factor authentication (MFA), secure HTTP-Only SameSite cookies, session rotation on privilege escalation, and strong password hashing algorithms (Argon2id, bcrypt).
- Continuous Security Automation (DevSecOps): Integrate Static Application Security Testing (SAST), Dependency Scanning (SCA), and Dynamic Application Security Testing (DAST) into CI/CD pipelines.
2. Threat Modeling & Vulnerability Remediation Lifecycle
[ Application Codebase ]
│
├──▶ [ SAST Scanner (Semgrep / SonarQube) ] ──(Code Flaws)
├──▶ [ SCA Scanner (Trivy / Dependabot) ] ────(Vulnerable Dependencies)
▼
[ Security Audit Engine ]
│
│ 1. Triaging & Threat Modeling (STRIDE / DREAD)
▼
[ Security Remediation Pipeline ]
│ 2. Apply Parameterization & Sanitization
▼
[ DAST Verification (OWASP ZAP) ] ──▶ [ Hardened Production Deployment ]
| Vulnerability Class | Root Cause | Primary Defensive Remediation |
|---|---|---|
| SQL Injection (SQLi) | String concatenation in database queries | Parameterized Prepared Statements |
| Cross-Site Scripting (XSS) | Unescaped output rendered in HTML context | Content Security Policy (CSP) & DOM Encoding |
| Broken Access Control | Missing authorization checks on record IDs | Server-side RBAC / ABAC evaluation |
| CSRF | Cross-origin request forgery on cookie auth | Anti-CSRF Tokens & SameSite=Strict cookies |
| Insecure Direct Object Reference (IDOR) | Exposing raw database primary keys | Tenant-scoped database queries & UUIDs |
3. Anti-Patterns & Common Vulnerabilities
- Anti-Pattern: String Concatenation in SQL Statements (
"SELECT * FROM users WHERE email = '" + input + "'")- Risk: High vulnerability to SQL Injection, leading to unauthorized database dump or remote code execution.
- Remediation: Use ORMs or parameterized query placeholders (
SELECT * FROM users WHERE email = $1).
- Anti-Pattern: Disabling TLS Certificate Validation (
rejectUnauthorized: falseorverify=False)- Risk: Vulnerable to Man-in-the-Middle (MitM) traffic interception and credential theft.
- Remediation: Enforce strict CA certificate validation across all HTTP client stubs.
- Anti-Pattern: Storing Plaintext Passwords or Using Weak Hashes (MD5 / SHA1)
- Risk: Instant offline dictionary credential crack on database breach.
- Remediation: Hash credentials with Argon2id or bcrypt with appropriate cost factors.
4. Production Defensive Security Code Snippets
A. Python Secure Database Access & Input Parameterization (secure_db.py)
#!/usr/bin/env python3
"""
Production Secure Database Access Layer using Parameterized Queries & Argon2id Hashing
"""
import os
import psycopg2
from psycopg2.extras import RealDictCursor
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
ph = PasswordHasher()
class SecureUserRepository:
def __init__(self, db_url: str):
self.db_url = db_url
def get_connection(self):
# Enforce SSL/TLS for database connections
return psycopg2.connect(self.db_url, sslmode='verify-full', cursor_factory=RealDictCursor)
def register_user(self, email: str, raw_password: str) -> dict:
"""
Hashes password securely with Argon2id and inserts user via Parameterized Query.
"""
password_hash = ph.hash(raw_password)
query = """
INSERT INTO users (email, password_hash, created_at)
VALUES (%s, %s, NOW())
RETURNING id, email, created_at;
"""
with self.get_connection() as conn:
with conn.cursor() as cursor:
cursor.execute(query, (email, password_hash))
user = cursor.fetchone()
conn.commit()
return dict(user)
def authenticate_user(self, email: str, candidate_password: str) -> bool:
"""
Validates login credentials against secure hash, immune to SQL Injection.
"""
query = "SELECT password_hash FROM users WHERE email = %s;"
with self.get_connection() as conn:
with conn.cursor() as cursor:
cursor.execute(query, (email,))
record = cursor.fetchone()
if not record:
return False
try:
return ph.verify(record['password_hash'], candidate_password)
except VerifyMismatchError:
return False
B. Node.js Express Hardened Security Middleware (security_headers.js)
import express from 'express';
import helmet from 'helmet';
import rateLimit from 'express-rate-limit';
const app = express();
// 1. Apply Helmet to set robust HTTP Security Headers
app.use(helmet({
contentSecurityPolicy: {
directives: {
defaultSrc: ["'self'"],
scriptSrc: ["'self'", "https://trusted-cdn.com"],
styleSrc: ["'self'", "'unsafe-inline'"],
imgSrc: ["'self'", "data:", "https:"],
connectSrc: ["'self'"],
fontSrc: ["'self'"],
objectSrc: ["'none'"],
upgradeInsecureRequests: [],
},
},
referrerPolicy: { policy: 'strict-origin-when-cross-origin' },
hsts: { maxAge: 31536000, includeSubDomains: true, preload: true },
}));
// 2. Enforce Strict Rate Limiting to prevent brute-force attacks
const apiLimiter = rateLimit({
windowMs: 15 * 60 * 1000, // 15 minutes
max: 100, // Limit each IP to 100 requests per window
standardHeaders: true,
legacyHeaders: false,
message: { status: 429, error: 'Too many requests, please try again later.' }
});
app.use('/api/', apiLimiter);
// 3. Secure Cookie Configuration for Session Tokens
app.use((req, res, next) => {
res.cookie('session', 'xyz123', {
httpOnly: true, // Prevents XSS cookie theft
secure: true, // Requires HTTPS
sameSite: 'strict', // Prevents CSRF
maxAge: 3600000
});
next();
});
app.get('/api/health', (req, res) => res.json({ status: 'SECURE_OK' }));
app.listen(8080, () => console.log('Secure server listening on port 8080'));
04 同仓库更多 Skills
security-audit
Comprehensive security guidance, source code audit, vulnerability assessment, and penetration test review for codebases, APIs, microservices, CLI tools, libraries, and LLM-backed applications. Triggers on requests to audit a codebase, conduct security reviews, find vulnerabilities or flaws, pen-test source code, or when the user asks in Arabic (فحص أمني، تدقيق الكود أمنياً، مراجعة الثغرات، فحص أمان المشروع). Supports Guidance mode (focused review) and Full Audit mode (deterministic 6-phase harness).
malware-analysis-reversing
Production malware analysis workflows, reverse engineering methodologies, isolated sandbox triage, static/dynamic binary analysis, memory forensics, and YARA detection rule authoring.
oauth2-oidc-security-flows
Implement enterprise OAuth 2.1 and OpenID Connect (OIDC) authorization code flow with Proof Key for Code Exchange (PKCE), state and nonce verification, refresh token rotation, token revocation, and centralized IdP federation (Keycloak, Auth0, Okta). Trigger when building secure authentication, single sign-on (SSO), or third-party delegated authorization.
jwt-session-management-hardening
Harden JWT-based authentication and session lifecycles using asymmetric signing (RS256/EdDSA), JWKS rotation, strict claims validation, Redis-backed sliding window sessions, revocation lists, and secure HttpOnly cookie storage. Trigger when implementing token validation, session revocation, or hardening API authentication.
soc2-compliance-automation
Best practices for implementing SOC 2 Type II compliance controls, continuous evidence collection, infrastructure policy-as-code, and automated security monitoring. Use when automating Trust Services Criteria (Security, Availability, Confidentiality, Processing Integrity, Privacy), audit logging, IAM least privilege, or CI/CD security gates.
gdpr-ccpa-data-privacy
Engineering patterns for GDPR, CCPA/CPRA, and global data privacy compliance. Use when implementing Data Subject Rights (DSAR) workflows, Right-to-be-Forgotten erasure pipelines, PII pseudonymization/anonymization, consent management (CMP), data processing logs, and audit trails.