skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
midudev/autoskills57 installs

rails-security-review

Performs security audits and vulnerability assessments on Ruby on Rails application code. Use when reviewing Rails code for security risks, assessing authentication or authorization, auditing parameter handling, redirects, file uploads, secrets management, or checking for XSS, CSRF, SSRF, SQL injection, and other common vulnerabilities.

How do I install this agent skill?

npx skills add https://github.com/midudev/autoskills --skill rails-security-review
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    This skill provides a structured framework for auditing Ruby on Rails applications for security vulnerabilities. It consists of instructional guidelines for identifying common flaws such as SQL injection, XSS, and authorization bypasses. No malicious patterns, executable code, or data exfiltration risks were detected.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

What does this agent skill do?

Rails Security Review

Use this skill when the task is to review or harden Rails code from a security perspective.

Core principle: Prioritize exploitable issues over style. Assume any untrusted input can be abused.

HARD-GATE: Authorization Findings Lead the Report

BEFORE returning your security review, verify:
  1. The FIRST finding section in your output is "Authentication & Authorization"
  2. SQL injection, XSS, or other findings come AFTER auth/authz — even if
     they feel more severe or were discovered first
  3. If no auth/authz issue exists, the report still opens with an explicit
     "Authentication & Authorization: no issues found" line BEFORE any other
     finding category

Quick Reference

AreaKey Checks
AuthPermissions on every sensitive action
ParamsNo permit!, whitelist only safe attributes
QueriesParameterized — no string interpolation in SQL
RedirectsConstrained to relative paths or allowlist
OutputNo html_safe/raw on user content
SecretsEncrypted credentials, never in code or logs
FilesValidate filename, content type, destination

Review Order

  1. Check authentication and authorization boundaries.
  2. Check parameter handling and sensitive attribute assignment.
  3. Check redirects, rendering, and output encoding.
  4. Check file handling, network calls, and background job inputs.
  5. Check secrets, logging, and operational exposure.
  6. Verify each finding: Confirm it is exploitable with a concrete attack scenario before reporting. Exclude false positives (e.g., html_safe on a developer-defined constant, not user input).

Severity Levels

High

  • Missing or bypassable authorization checks
  • SQL, shell, YAML, or constantization injection paths
  • Unsafe redirects or SSRF-capable outbound requests
  • File upload handling that trusts filename, content type, or destination blindly
  • Secrets or tokens stored in code, logs, or unsafe config

Medium

  • Unscoped mass assignment through weak parameter filtering
  • User-controlled HTML rendered without clear sanitization
  • Sensitive data logged in plaintext
  • Security-relevant behavior hidden in callbacks or background jobs without guardrails
  • Brittle custom auth logic where framework primitives would be safer

Review Checklist

  • Are permissions enforced on every sensitive action?
  • Are untrusted inputs validated before database, filesystem, or network use?
  • Are redirects and URLs constrained?
  • Are secrets stored and logged safely?
  • Are security assumptions explicit and testable?

Examples

High-severity (unscoped redirect):

# Bad: user-controlled redirect — open redirect / phishing risk
redirect_to params[:return_to]

# Good: relative path only
redirect_to root_path
# Good: allowlist
SAFE_PATHS = %w[/dashboard /settings].freeze
redirect_to(SAFE_PATHS.include?(params[:return_to]) ? params[:return_to] : root_path)

Medium-severity (mass assignment):

# Bad: privilege escalation risk
params.require(:user).permit!

# Good: explicit whitelist — never include role, admin, or privilege fields
params.require(:user).permit(:name, :email)

Pitfalls

See PITFALLS.md for the full list. Critical anti-patterns: permit! on any parameter set, html_safe on user content, SQL string interpolation, secrets in committed files.

Output Style

Section order per the HARD-GATE. Every heading appears even when empty (write "No issues found.").

## Authentication & Authorization
## Parameter Handling & Mass Assignment
## Query Safety (SQL / NoSQL / shell injection)
## Output Encoding & Redirects
## Secrets, Logging & Operational Exposure

Each finding carries:

  • Severity: High or Medium (not "Critical")
  • Attack path: input → reach → impact
  • Affected file: path + line, e.g. app/controllers/documents_controller.rb:42
  • Mitigation: smallest credible fix

Integration

SkillWhen to chain
rails-code-reviewFor full code review including non-security concerns
rails-architecture-reviewWhen security issues stem from architectural problems
rails-migration-safetyWhen reviewing migration security (data exposure, constraints)

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/midudev/autoskills/rails-security-review">View rails-security-review on skillZs</a>