firebase-security-rules-auditor
firebase/agent-skills
Audit Firebase security rules for vulnerabilities, privilege escalation, and compliance gaps.
What is firebase-security-rules-auditor?
This skill evaluates Firebase Firestore and Cloud Storage security rules against a rigorous red-team checklist, identifying vulnerabilities like privilege escalation, update bypasses, resource exhaustion, and ownership validation gaps. Use it when reviewing rules, running security assessments, or scoring against audit criteria.
- Detects create vs. update rule inconsistencies that enable privilege escalation
- Identifies authority-source issues where sensitive fields rely on user-provided data
- Validates type safety and field-level constraints (string length, array size limits)
- Checks ownership and role-based access control (hasOnly, diff, uid matching)
- Assesses business logic alignment and resource exhaustion risks
- Scores findings on a 1–5 scale (Critical to Secure) with remediation guidance
How to install firebase-security-rules-auditor
npx skills add https://github.com/firebase/agent-skills --skill firebase-security-rules-auditorHow to use firebase-security-rules-auditor
- 1.Provide your Firestore or Cloud Storage security rules (in text or JSON format)
- 2.The auditor will evaluate them against the mandatory checklist: update bypass, authority source, business logic, storage abuse, type safety, and ownership checks
- 3.Review the JSON output containing score (1–5), summary, and detailed findings with severity levels
- 4.Address critical and major findings before deployment; prioritize moderate and minor issues in the next iteration
Use cases
- Red-team assessment of Firestore rules before production deployment
- Compliance audit of existing Cloud Storage and Firestore security policies
- Review of role-based access control (RBAC) and ownership checks in multi-tenant apps
- Detection of self-assignment vulnerabilities and update-bypass chains
- Security scoring and remediation prioritization for rule refactoring
- Security auditors and penetration testers
- Firebase developers responsible for rule design and review
- DevSecOps engineers conducting compliance assessments
- Team leads evaluating rule maturity before production
firebase-security-rules-auditor FAQ
Firestore and Cloud Storage security rules only. It does not cover Firebase Auth, Crashlytics, Remote Config, or database queries.
Scores range from 1 (Critical vulnerabilities) to 5 (Secure). Each finding is assigned a severity (critical, major, moderate, minor) based on impact: unauthorized access and privilege escalation are critical; broken business logic is major; PII exposure and inconsistent validation are moderate; self-data corruption and missing minor type checks are minor.
It compares create and update rules to detect if a user can create a valid document then update it into an invalid state—e.g., changing their role, bypassing size limits, or corrupting data types.
Yes. Hardcoded admin emails are acceptable if email_verified is also checked and no escalation path exists for additional admins to self-assign privileges.
Prioritize critical and major findings for immediate remediation. Moderate issues should be addressed before production. Minor issues can be scheduled for the next iteration. Each finding includes a recommendation.
Full instructions (SKILL.md)
Source of truth, from firebase/agent-skills.
name: firebase-security-rules-auditor description: >- Audits Firebase (Firestore, Cloud Storage) security rules for vulnerabilities, privilege escalation, role bypasses, create vs update inconsistencies, resource exhaustion, type safety, size limits, and hasOnly ownership checks. Use when auditing/reviewing rules, running red-team rule assessments, or scoring against auditor checklists. Don't use for Firebase CLI (login, deploy), Auth, Crashlytics, Remote Config, or database queries. metadata: category: CloudSecurity
Overview
This skill acts as an auditor for Firebase Security Rules, evaluating them against a rigorous set of criteria to ensure they are secure, robust, and correctly implemented.
Scoring Criteria
Assessment: Security Validator (Red Team Edition)
You are a Senior Security Auditor and Penetration Tester specializing in Firestore. Your goal is to find "the hole in the wall." Do not assume a rule is secure because it looks complex; instead, actively try to find a sequence of operations to bypass it.
Mandatory Audit Checklist:
- The Update Bypass: Compare 'create' and 'update' rules. Can a user create a valid document and then 'update' it into an invalid or malicious state (e.g., changing their role, bypassing size limits, or corrupting data types)?
- Authority Source: Does the security rely on user-provided data (request.resource.data) for sensitive fields like 'role', 'isAdmin', or 'ownerId'? Carefully consider the source for that authority.
- Business Logic vs. Rules: Does the rule set actually support the app's purpose? (e.g., In a collaboration app, can collaborators actually read the data? If not, the rules are "broken" or will force insecure workarounds).
- Storage Abuse: Are there string length or array size limits? If not, label it as a "Resource Exhaustion/DoS" risk.
- Type Safety: Are fields checked with 'is string', 'is int', or 'is timestamp'?
- Field-Level vs. Identity-Level Security: Be careful with rules that use
hasOnly()ordiff(). While these restrict which fields can be updated, they do NOT restrict who can update them unless an ownership check (e.g.,resource.data.uid == request.auth.uid) is also present. If a rule allows any authenticated user to update fields on another user's document without a corresponding ownership check, it is a data integrity vulnerability.
Admin Bootstrapping & Privileges:
The admin bootstrapping process is limited in this app. If the rules use a single hardcoded admin email (e.g., checking request.auth.token.email == 'admin@example.com'), this should NOT count against the score as long as:
- email_verified is also checked (request.auth.token.email_verified == true).
- It is implemented in a way that does not allow additional admins to add themselves or leave an escalation risk open.
Scoring Criteria (1-5):
- 1 (Critical): Unauthorized data access (leaks), privilege escalation, or total validation bypass.
- 2 (Major): Broken business logic, self-assigned roles, bypass of controls.
- 3 (Moderate): PII exposure (e.g., public emails), Inconsistent validation (create vs update) on critical fields
- 4 (Minor): Problems that result in self-data corruption like update bypasses that only impact the user's own data, lack of size limits, missing minor type checks or over-permissive read access on non-sensitive fields.
- 5 (Secure): Comprehensive validation, strict ownership, and role-based access via secure ACLs.
Return your assessment in JSON format using the following structure:
{
"score": 1,
"summary": "overall assessment",
"findings": [
{
"check": "checklist item",
"severity": "critical|major|moderate|minor",
"issue": "description",
"recommendation": "fix"
}
]
}
Related skills
More from firebase/agent-skills and the wider catalog.
