prowler-compliance — Claude Code skill: what it does, how to install
Handles Prowler compliance frameworks end to end: authoring the JSON, syncing with the upstream catalog, and reviewing how checks map to requirements.
Apache-2.0 ★ 15,302 updated 2026-10-25
npx skills add prowler-cloud/prowler --skill prowler-compliance -a claude-codeWhat prowler-compliance does
The skill covers the whole life of a Prowler compliance framework: writing a new JSON file, adding requirements, attaching checks to controls, syncing with the source catalog, and repairing the usual breakage — duplicate IDs, an empty Version, a wrong Section, references to retired checks. It also adds ConfigRequirements guardrails, so a configurable check cannot satisfy a requirement under a loosened config.
Pick the schema before you write anything. Universal puts one file at prowler/compliance/<framework>.json for any number of providers, uses lowercase keys, declares its attributes in attributes_metadata inside that JSON, and builds table output from outputs.table_config. Legacy keeps a file per provider under prowler/compliance/<provider>/, needs a Pydantic class in compliance_models.py, plus a formatter package registered in compliance.py, __main__.py and export.py.
The gap matters for a new framework. Universal asks for no Python edits at all, while legacy costs three files and three registrations. Failure handling splits the same way: a bad file stops the legacy loader with sys.exit(1), the universal one logs it and moves on. The skill runs with Read, Edit, Write, Glob, Grep, Bash, WebFetch and WebSearch.
What it helps with
- write a new framework as universal JSON
- extend an existing framework to another provider
- review check-to-control mappings as an auditor
- fix duplicate IDs or an empty
Versionin compliance JSON - add
ConfigRequirementsso a loosened config stops satisfying a requirement
Example prompts for the agent
- Create a universal framework
my_framework_1.0.jsonunderprowler/compliance/withattributes_metadata, then map the checks to its requirements. - Sync
cis_controls_8.1.jsonagainst the upstream CIS Controls catalog and list what drifted. - Audit
dora_2022_2554.json: does every check really cover the requirement it is attached to?
How to install prowler-compliance
1Skills CLI (Vercel)
npx skills add prowler-cloud/prowler --skill prowler-compliance -a claude-code2Manually: put the files in place
~/.claude/skills/prowler-compliance/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/prowler-compliance/
1Skills CLI (Vercel)
npx skills add prowler-cloud/prowler --skill prowler-compliance -a codex2Manually: put the files in place
.agents/skills/prowler-compliance/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add prowler-cloud/prowler --skill prowler-compliance -a cursor2Manually: put the files in place
.cursor/skills/prowler-compliance/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install prowler-cloud/prowler skills/prowler-compliance2Manually: put the files in place
.github/skills/prowler-compliance/SKILL.md1Skills CLI (Vercel)
npx skills add prowler-cloud/prowler --skill prowler-compliance -a gemini-cli2Platform CLI
gemini skills install https://github.com/prowler-cloud/prowler --path skills/prowler-complianceManually: put the files in place
.devin/skills/prowler-compliance/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add prowler-cloud/prowler --skill prowler-compliance -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about prowler-compliance
How do I install prowler-compliance in Claude Code?
Run npx skills add prowler-cloud/prowler --skill prowler-compliance -a claude-code. The skill lands at ~/.claude/skills/prowler-compliance/SKILL.md.
What does prowler-compliance do?
It creates, syncs and audits Prowler compliance frameworks: edits the JSON, adds guardrails and output formatters, and reviews how checks map to requirements.
Universal schema or legacy — what is the difference?
Universal holds every provider in one file, declares attributes through attributes_metadata, and drives table output from outputs.table_config with no code changes. Legacy needs one file per provider, a Pydantic class in compliance_models.py, and a formatter package with registrations.
Source text
SKILL.md · Apache-2.0
---
name: prowler-compliance
description: >
Creates, syncs, audits and manages Prowler compliance frameworks end-to-end.
Covers the two supported JSON schemas (universal multi-provider and legacy
per-provider), the SDK model tree (legacy attribute classes, universal
ComplianceFramework, ConfigRequirements guardrails), output formatters
(legacy per-framework + universal data-driven), API/UI consumption, upstream
sync workflows, and cloud-auditor check-mapping reviews.
Trigger: When working with compliance frameworks (CIS, CIS Controls, NIST,
PCI-DSS, SOC2, GDPR, ISO27001, ENS, MITRE ATT&CK, CCC, C5, CSA CCM, DORA,
KISA ISMS-P, ASD Essential Eight, DISA STIG, CISA SCuBA, SecNumCloud,
FedRAMP, HIPAA, NIS2, Prowler ThreatScore), creating a universal
multi-provider framework, adding ConfigRequirements guardrails, syncing with
upstream catalogs, auditing check-to-requirement mappings, adding output
formatters, or fixing compliance JSON bugs (duplicate IDs, empty Version,
wrong Section, stale check refs).
license: Apache-2.0
metadata:
author: prowler-cloud
version: "2.0"
scope: [root, sdk]
auto_invoke:
- "Creating/updating compliance frameworks"
- "Creating a universal (multi-provider) compliance framework"
- "Mapping checks to compliance controls"
- "Adding ConfigRequirements guardrails to compliance requirements"
- "Syncing compliance framework with upstream catalog"
- "Auditing check-to-requirement mappings as a cloud auditor"
- "Adding a compliance output formatter (per-provider class + table dispatcher)"
- "Fixing compliance JSON bugs (duplicate IDs, empty Section, stale refs)"
allowed-tools: Read, Edit, Write, Glob, Grep, Bash, WebFetch, WebSearch, Task
---
## When to Use
Use this skill when:
- Creating a new compliance framework for any provider — **decide universal vs legacy first** (see below)
- **Syncing an existing framework with an upstream source of truth** (CIS, FINOS CCC, CSA CCM, NIST, ENS, etc.)
- Adding requirements to existing frameworks, or extending a universal framework to a new provider
- Mapping checks to compliance controls
- **Adding `ConfigRequirements` guardrails** so configurable checks can't silently satisfy a requirement with a loosened config
- **Auditing existing check mappings as a cloud auditor** ("are these mappings correct?", "which checks apply?", "review the mappings")
- **Adding a new legacy output formatter** (table dispatcher + per-provider classes + CSV models)
- **Fixing JSON bugs**: duplicate IDs, empty Version, wrong Section, stale check refs, inconsistent FamilyName, padded tangential check mappings
- Investigating why a finding/check isn't showing under the expected compliance framework in the UI
- Understanding compliance framework structures and attributes
The authoritative contributor doc is `docs/developer-guide/security-compliance-framework.mdx` —
keep this skill and that doc consistent when either changes. For **reviewing**
a compliance PR, use the sister skill
[prowler-compliance-review](../prowler-compliance-review/SKILL.md) instead.
## Universal vs Legacy: The First Decision
Prowler supports **two JSON schemas**. Choosing wrong means unnecessary Python
code, so decide this before anything else. At load time both converge: legacy
files are adapted into the universal `ComplianceFramework` model
(`adapt_legacy_to_universal()`), so the difference is about **authoring cost
and capabilities**, not about what the rest of Prowler sees.
### Side-by-side comparison
| | Universal (recommended for new frameworks) | Legacy provider-specific |
|---|---|---|
| File location | `prowler/compliance/<framework>.json` (top level) | `prowler/compliance/<provider>/<framework>_<version>_<provider>.json` |
| Providers | Any number, one file (`checks` dict keyed by provider) | Exactly one provider per file (one file per provider to multi-cover) |
| Key style | lowercase (`framework`, `requirements`, `checks`) | Capitalized (`Framework`, `Requirements`, `Checks`) |
| Attribute schema | Declared **in the JSON itself** via `attributes_metadata`, validated at load | Pydantic class per framework family in `compliance_models.py` (code change for new shapes) |
| Attributes per requirement | One flat dict (`attributes: {...}`) | List of objects (`Attributes: [{...}]`) — only `Attributes[0]` is used downstream |
| Table/CSV/OCSF output | Data-driven from `outputs.table_config` — **zero Python changes** | Formatter package + registrations in `compliance.py`, `__main__.py`, `export.py` |
| Guardrails field | `config_requirements` (+ mandatory `Provider` per constraint) | `ConfigRequirements` (`Provider` omitted) |
| Loader behavior on error | Lenient: logs + skips file (`load_compliance_framework_universal`) | Fail-fast: `sys.exit(1)` (`load_compliance_framework`) |
| Loaded by | Only `get_bulk_compliance_frameworks_universal()` | Both loaders (`Compliance.get_bulk()` + universal, via adapter) |
| Shipped examples | `cis_controls_8.1.json`, `csa_ccm_4.0.json`, `dora_2022_2554.json` | Everything else (~105 files across 11 providers) |
### When to use which
**Use universal when** (any of these):
- The framework is **new to Prowler** — no existing attribute class, no
existing formatter. This is the default: zero Python changes needed.
- The framework spans (or will span) **more than one provider** — DORA, CSA
CCM, CIS Controls. One file covers all providers; extending to a new
provider is a one-line `checks` edit.
- The attribute shape is **unique to this framework** — declare it in
`attributes_metadata` instead of adding a Pydantic class to the Union.
**Use legacy only when extending an existing legacy family**:
- A new **version** of a shipped legacy framework (CIS 8.0 for AWS → new
`cis_8.0_aws.json`, same `CIS_Requirement_Attribute`, same `cis/` formatter).
- An existing legacy framework for a **new provider** (ENS for m365 → new
`ens_rd2022_m365.json` + `ens_m365.py` transformer).
- Consistency with the family matters more than the universal benefits — a
lone `cis_8.0_aws` in universal format while 20+ CIS files stay legacy
would fragment the family.
**Never**: start a brand-new single-provider framework as legacy "because it's
only AWS today". Universal handles single-provider fine (the `checks` dict
just has one key) and you skip 3 output files + 3 registrations.
### The same requirement in both schemas
Universal (`prowler/compliance/my_framework_1.0.json`):
```json
{
"framework": "My-Framework",
"name": "My Framework 1.0",
"version": "1.0",
"description": "...",
"attributes_metadata": [
{"key": "Section", "type": "str", "required": true},
{"key": "Service", "type": "str"}
],
"outputs": {"table_config": {"group_by": "Section"}},
"requirements": [
{
"id": "MF-1.1",
"name": "Root MFA",
"description": "Root account must have MFA enabled.",
"attributes": {"Section": "IAM", "Service": "iam"},
"checks": {
"aws": ["iam_root_mfa_enabled"],
"azure": []
}
}
]
}
```
Legacy (`prowler/compliance/aws/my_framework_1.0_aws.json` — plus a second
file per extra provider, plus formatter + registrations):
```json
{
"Framework": "My-Framework",
"Name": "My Framework 1.0 for AWS",
"Version": "1.0",
"Provider": "AWS",
"Description": "...",
"Requirements": [
{
"Id": "MF-1.1",
"Name": "Root MFA",
"Description": "Root account must have MFA enabled.",
"Attributes": [
{"ItemId": "MF-1.1", "Section": "IAM", "Service": "iam"}
],
"Checks": ["iam_root_mfa_enabled"]
}
]
}
```
Same control, but the universal file already covers Azure, validates its own
attribute schema, and renders table/CSV/OCSF with no code. Field-by-field
references for each schema follow below.
## Architecture (Mental Model)
Prowler compliance is a four-layer system. Bugs usually happen where one layer
doesn't match another, so know all four before touching anything.
### Layer 1: SDK / Core Models — `prowler/lib/check/`
All in **Pydantic v1** (`from pydantic.v1 import ...`). Three model groups live
in `compliance_models.py`:
**Legacy tree** — `Compliance` → `Compliance_Requirement` / `Mitre_Requirement`:
- One `*_Requirement_Attribute` class per framework family. Registered today (Union order matters):
`ASDEssentialEight`, `CIS`, `ENS`, `ISO27001_2013`, `AWS_Well_Architected`,
`KISA_ISMSP`, `Prowler_ThreatScore`, `CCC`, `C5Germany`, `CSA_CCM`, `STIG`
(Okta IDaaS), and `Generic_Compliance_Requirement_Attribute` as fallback.
- **Generic MUST stay LAST** in `Compliance_Requirement.Attributes: list[Union[...]]` —
Pydantic v1 tries union members in order; Generic first would swallow every
framework-specific attribute. NIST 800-53/CSF, PCI DSS, GDPR, HIPAA, SOC2,
FedRAMP, SecNumCloud etc. intentionally use Generic.
- A `root_validator` rejects empty `Framework`, `Provider` or `Name`.
- MITRE uses the separate `Mitre_Requirement` model (`Tactics`, `SubTechniques`,
`Platforms`, `TechniqueURL` at requirement top level, per-provider
`Mitre_Requirement_Attribute_{AWS,Azure,GCP}`).
**Universal tree** — `ComplianceFramework` → `UniversalComplianceRequirement`:
- Flat `attributes: dict` per requirement, schema declared in
`attributes_metadata` (key, label, type, enum, required, `enum_display`,
`enum_order`, `output_formats`). A `root_validator` rejects missing required
keys, unknown keys (drift guard), enum violations, and int/float/bool type
mismatches. If `attributes_metadata` is omitted, **no validation runs**.
- `checks: dict[provider, list[check_id]]` — the provider list of the framework
is **derived** from these keys (`get_providers()` / `supports_provider()`);
the top-level `provider` field is only a fallback.
- `outputs.table_config` (group_by, split_by, scoring, labels) drives the CLI
table; `outputs.pdf_config` exists in the model but **is not consumed by the
API PDF pipeline yet** (see Layer 4).
**Guardrails** — `Compliance_Requirement_ConfigConstraint`:
- Fields `Check`, `ConfigKey`, `Operator` (`lte|gte|eq|in|subset|superset`),
`Value`, optional `Provider` (required in universal multi-provider files).
- A `root_validator` rejects Value/Operator type mismatches at load time.
- Evaluation is centralized in `prowler/lib/check/compliance_config_eval.py`
(`evaluate_config_constraints`, `apply_config_status`, `get_effective_status`,
`CONFIG_NOT_VALID_PREFIX = "Configuration not valid for this requirement."`),
shared by CSV/OCSF/table outputs **and** the API backend. A violated
constraint forces the requirement to FAIL and prepends the reason to
`status_extended`. Constraints whose `ConfigKey` is absent from
`audit_config` are skipped (defaults assumed compliant).
**Loaders**:
- `Compliance.get_bulk(provider)` — legacy: scans only
`prowler/compliance/{provider}/` (+ external JSONs via the
`prowler.compliance` entry-point group). Does NOT see top-level universal files.
- `get_bulk_compliance_frameworks_universal(provider)` — scans **both** the
top-level `prowler/compliance/` and every provider subdirectory, adapting
legacy files via `adapt_legacy_to_universal()` (flattens `Attributes[0]` to a
dict, wraps `Checks` as `{provider: [...]}`, infers `attributes_metadata`).
Also loads external universal frameworks via the
`prowler.compliance.universal` entry-point group (built-ins win collisions).
- `get_check_compliance(finding, provider_type, bulk_checks_metadata)` lives in
**`prowler/lib/outputs/compliance/compliance_check.py`** (not in
`lib/check/compliance.py`). It builds the per-finding dict keyed
`f"{Framework}-{Version}"` **only when Version is non-empty** — an empty
Version silently produces the key `"{Framework}"` and breaks downstream
filters and tests.
- `prowler/lib/check/compliance.py` now contains only
`update_checks_metadata_with_compliance()`.
### Layer 2: JSON Catalogs — `prowler/compliance/`
See "Compliance Catalog Coverage" below.
### Layer 3: Output Formatters — `prowler/lib/outputs/compliance/`
**Universal path** (no Python needed per framework):
- `universal/universal_table.py` — `get_universal_table()`, renders the CLI
table from `outputs.table_config` + `attributes_metadata`.
- `universal/universal_output.py` — `UniversalComplianceOutput`, builds the CSV
Pydantic model **dynamically** from `attributes_metadata`.
- `universal/ocsf_compliance.py` — `OCSFComplianceOutput`; OCSF output is
**always generated** for universal frameworks regardless of `--output-formats`.
- Orchestrated by `process_universal_compliance_frameworks()` in
`compliance.py`, which runs **before** any legacy dispatch and removes the
processed frameworks from the set.
**Legacy path** — per-framework directory, usually:
```text
{framework}/
├── __init__.py
├── {framework}.py # get_{framework}_table() summary-table function
├── {framework}_{provider}.py # One ComplianceOutput subclass per provider
└── models.py # One Pydantic CSV row model per provider
```
Directories today: `asd_essential_eight`, `aws_well_architected`, `c5`, `ccc`,
`cis`, `cisa_scuba`, `ens`, `generic`, `iso27001`, `kisa_ismsp`,
`mitre_attack`, `okta_idaas_stig`, `prowler_threatscore`, `universal`.
Known deviations (don't "fix" them without a reason): `iso27001/` has no table
file (falls to the generic table), `aws_well_architected/` has no per-provider
files, `cisa_scuba/` only ships googleworkspace.
- CSV writers emit `;`-delimited files with UPPERCASE headers
(`ComplianceOutput.batch_write_data_to_file`). Field names in `models.py`
are **public API** — renaming breaks downstream consumers.
- **Circular import rule**: the table file (`{framework}.py`) must not import
`Finding` directly or transitively (`compliance.compliance` → table module →
`ComplianceOutput` → `Finding` → `get_check_compliance` → cycle). Keep table
files bare (`colorama`, `tabulate`, `prowler.config.config`); when a module
genuinely needs both, use `if TYPE_CHECKING:` or function-local imports (see
`universal_output.py` / `process_universal_compliance_frameworks`).
- Legacy table functions have no docstrings; the universal ones do. Match the
style of the file family you're touching.
- Dispatcher `display_compliance_table()` in `compliance.py` order:
universal (`table_config`) first → `cis_` → `ens_` → `mitre_attack` →
`kisa` → `prowler_threatscore_` → `c5_` → `ccc_` → `asd_essential_eight`
(substring) → `okta_idaas_stig` → else provider hook
(`provider.display_compliance_table()`, may raise `NotImplementedError`) →
`get_generic_compliance_table()`. iso27001, aws_well_architected and
cisa_scuba ride the fallback on purpose.
### Layer 4: API / UI
- **API lazy loaders**: `api/src/backend/api/compliance.py` —
`LazyComplianceTemplate` / `LazyChecksMapping` (per-provider lazy caches over
`get_bulk_compliance_frameworks_universal`, with Gunicorn background warm-up).
- **API CSV export dispatch**: `COMPLIANCE_CLASS_MAP` in
`api/src/backend/tasks/jobs/export.py`, consumed from `tasks/tasks.py`. It is
a dict `provider → [(predicate, exporter_class)]` with `GenericCompliance` as
fallback. Predicates mix **`startswith` for multi-version families**
(`cis_`, `ens_`, `iso27001_`, `ccc_`, `cisa_scuba_`, ...) and **exact
`name == ...` for true singletons** (`mitre_attack_aws`,
`prowler_threatscore_*`, `asd_essential_eight_aws` — and inconsistently
`c5_azure`/`c5_gcp`, while aws uses `startswith("c5_")`). Rule of thumb: if
the framework can ever grow versions or variants, use `startswith`.
- **API overview ingestion**: `create_compliance_requirements()` in
`api/src/backend/tasks/jobs/scan.py` builds per-region rows from the lazy
template and persists `ComplianceRequirementOverview` (COPY with bulk-create
fallback) plus `ComplianceOverviewSummary`.
- **API PDF reports**: `api/src/backend/tasks/jobs/reports/` — hardcoded
`FRAMEWORK_REGISTRY` (own `FrameworkConfig` dataclass, NOT the SDK
`PDFConfig`) with one generator class per framework. Only
`prowler_threatscore`, `ens`, `nis2`, `csa_ccm` and `cis` have PDFs today;
adding one means a generator class + registry entry + wiring in `report.py`.
- **UI mapper routing**: `ui/lib/compliance/compliance-mapper.ts` —
`getComplianceMappers()` keyed by the JSON's `framework` value
(e.g. `"CIS"`, `"CIS-Controls"`, `"DORA"`, `"Okta-IDaaS-STIG"`). Unregistered
frameworks **fall back to the generic mapper + `GenericCustomDetails`
automatically** — a dedicated mapper/detail panel is a first-class upgrade,
not a requirement to render.
- **UI grouping varies per mapper**: generic/cis group by
`Section`/`SubSection`, iso by `Category`, ccc by `FamilyName`. All read
`attributes[0]` — inconsistent values within one JSON become separate tree
branches, so normalize before shipping.
- **UI types**: `ui/types/compliance.ts` — one `*AttributesMetadata` interface
per framework, added to the `AttributesItemData` metadata union.
- **UI icons**: `ui/components/icons/compliance/` + `IconCompliance.tsx`.
Registration is an ordered substring match (`COMPLIANCE_LOGOS`): put
framework-specific keywords **before** generic ones (`nist` before `nis2`,
`cisa` before `cis`; `aws` deliberately last).
### The CLI Pipeline (end-to-end)
```text
prowler aws --compliance cis_7.0_aws # framework key = JSON basename
↓
Compliance.get_bulk("aws") # legacy frameworks
get_bulk_compliance_frameworks_universal("aws") # legacy (adapted) + universal
↓
update_checks_metadata_with_compliance() # attaches compliance to CheckMetadata
↓
execute_checks() → Finding objects
↓
get_check_compliance(finding, "aws", bulk) # dict "{Framework}-{Version}" → [req_ids]
↓
process_universal_compliance_frameworks() # universal: CSV + OCSF, then removed from set
per-provider elif branches in __main__.py # legacy: AWSCIS(...).batch_write_data_to_file()
↓
display_compliance_table() # universal table first, then legacy elifs,
# then generic fallback
```
---
## Compliance Catalog Coverage
Counts as of 2026-07 (109 JSON files). Regenerate before trusting them:
```bash
for d in prowler/compliance/*/; do printf "%s: %s\n" "$(basename $d)" "$(ls $d*.json 2>/dev/null | wc -l)"; done
ls prowler/compliance/*.json # universal, top-level
```
**Universal (top-level, multi-provider)**: `cis_controls_8.1.json` (18
providers), `csa_ccm_4.0.json` (aws/azure/gcp/alibabacloud/oraclecloud),
`dora_2022_2554.json` (aws/azure/gcp/alibabacloud/cloudflare).
**Legacy per-provider** (families, not exhaustive versions):
| Provider | # | Framework families |
|---|---|---|
| aws | 45 | CIS 1.4–7.0, NIST 800-53 r4/r5, NIST 800-171 r2, NIST CSF 1.1/2.0, PCI 3.2.1/4.0, ISO 27001 2013/2022, HIPAA, GDPR, SOC2, FedRAMP low/moderate r4 + 20x KSI low, ENS RD2022, MITRE ATT&CK, C5, CCC, CISA, FFIEC, RBI, Well-Architected (security/reliability), FTR, FSBP, AWS AI Security Framework, AWS Account Security Onboarding, Audit Manager Control Tower, GxP 21 CFR 11 / EU Annex 11, KISA ISMS-P 2023 (en+ko), NIS2, ASD Essential Eight, SecNumCloud 3.2, Prowler ThreatScore |
| azure | 19 | CIS 2.0–6.0, ISO 27001 2022, ENS RD2022, MITRE ATT&CK, PCI 4.0, HIPAA, SOC2, NIS2, RBI, C5, CCC, FedRAMP 20x KSI low, SecNumCloud 3.2, Prowler ThreatScore |
| gcp | 17 | CIS 2.0–5.0, ISO 27001 2022, ENS RD2022, MITRE ATT&CK, PCI 4.0, HIPAA, SOC2, NIS2, RBI, C5, CCC, FedRAMP 20x KSI low, SecNumCloud 3.2, Prowler ThreatScore |
| kubernetes | 8 | CIS 1.8–2.0.1, ISO 27001 2022, PCI 4.0, Prowler ThreatScore |
| m365 | 5 | CIS 4.0/6.0/7.0, ISO 27001 2022, Prowler ThreatScore |
| alibabacloud | 3 | CIS 2.0, SecNumCloud 3.2, Prowler ThreatScore |
| oraclecloud | 3 | CIS 3.0/3.1, SecNumCloud 3.2 |
| github | 2 | CIS 1.0/1.2.0 |
| googleworkspace | 2 | CIS 1.3, CISA SCuBA 0.6 |
| okta | 1 | Okta IDaaS STIG V1R2 |
| nhn | 1 | ISO 27001 2022 |
Providers with a compliance directory but no frameworks yet: cloudflare, iac,
linode, llm, mongodbatlas, openstack, stackit. Provider keys inside universal
`checks` dicts must match directory names under `prowler/providers/` (lowercase).
---
## Universal Schema Reference
Full spec in `docs/developer-guide/security-compliance-framework.mdx`. Skeleton:
```json
{
"framework": "DORA",
"name": "Digital Operational Resilience Act (DORA) 2022/2554",
"version": "2022/2554",
"description": "Shown in --list-compliance and PDF reports.",
"icon": "dora",
"attributes_metadata": [
{"key": "Pillar", "label": "Pillar", "type": "str", "required": true,
"enum": ["ICT Risk Management", "..."],
"output_formats": {"csv": true, "ocsf": true}},
{"key": "Article", "type": "str", "required": true}
],
"outputs": {
"table_config": {"group_by": "Pillar"},
"pdf_config": {"group_by_field": "Pillar", "charts": ["..."]}
},
"requirements": [
{
"id": "DORA-Art5",
"name": "Governance and organisation",
"description": "Requirement text verbatim from the source.",
"attributes": {"Pillar": "ICT Risk Management", "Article": "Article 5"},
"checks": {
"aws": ["iam_no_root_access_key"],
"azure": [],
"gcp": []
},
"config_requirements": [
{"Check": "iam_user_accesskey_unused", "Provider": "aws",
"ConfigKey": "max_unused_access_keys_days", "Operator": "lte", "Value": 45}
]
}
]
}
```
### Universal fields, top level (`ComplianceFramework`)
| Field | Type | Required | Notes |
|---|---|---|---|
| `framework` | string | Yes | Short identifier (`DORA`, `CSA-CCM`, `CIS-Controls`). This is the key the UI mapper routes on. |
| `name` | string | Yes | Human-readable full name. |
| `version` | string | No (never leave empty) | Framework version/edition (`8.1`, `2022/2554`). |
| `description` | string | Yes | Shown in `--list-compliance` and PDF reports. |
| `provider` | string | No | Fallback only — the effective provider list is derived from `checks` keys across requirements (`get_providers()`). |
| `icon` | string | No | Short icon slug. |
| `attributes_metadata` | array | No (strongly recommended) | Declares the schema of every `attributes` key. **If omitted, no attribute validation runs at all.** |
| `outputs` | object | No | `table_config` (CLI table) + `pdf_config` (modeled, not yet consumed by the API). |
| `requirements` | array | Yes | List of requirement objects (below). |
### Universal fields, per requirement (`UniversalComplianceRequirement`)
| Field | Type | Required | Notes |
|---|---|---|---|
| `id` | string | Yes | Unique within the framework. |
| `description` | string | Yes | Requirement text verbatim from the source. |
| `name` | string | No | Short title. |
| `attributes` | dict | No (default `{}`) | Flat dict; every key must be declared in `attributes_metadata` (unknown keys are rejected at load when metadata exists). |
| `checks` | dict | No (default `{}`) | `{provider: [check_ids]}`, lowercase keys matching `prowler/providers/` dirs. Empty list = manual requirement for that provider. |
| `config_requirements` | array | No | Guardrails; each constraint **must** carry `Provider`. |
| `tactics`, `sub_techniques`, `platforms`, `technique_url` | — | No | MITRE-style extras (auto-populated when adapting legacy MITRE files). |
### `attributes_metadata` entry fields (`AttributeMetadata`)
| Field | Type | Notes |
|---|---|---|
| `key` | string (required) | Attribute name as used in `requirement.attributes`. |
| `label` | string | Human-readable label for CSV headers / PDF. |
| `type` | string | `str` (default), `int`, `float`, `bool`, `list_str`, `list_dict`. Only int/float/bool are enforced at load; the rest are documentation. |
| `enum` | list | Allowed values — enforced at load. Use it whenever the value set is closed. |
| `required` | bool | Enforced at load: every requirement must carry the key non-null. |
| `enum_display` / `enum_order` | dict / list | Per-enum-value visual metadata (label, abbreviation, color, icon) and ordering for PDF rendering. |
| `chart_label` | string | Axis label when the attribute is used in charts. |
| `output_formats` | object | `{"csv": bool, "ocsf": bool}`, both default `true` — toggles inclusion per output. |
Key rules:
- `--compliance` key = JSON basename without `.json` (`dora_2022_2554`).
- Auto-discovered: no `__init__.py`, no formatter, no dispatcher registration.
- `table_config.group_by`, `pdf_config.group_by_field` and every
`charts[].group_by` must reference a key declared in `attributes_metadata`.
- Runtime type validation only covers `int`/`float`/`bool`; `str`/`list_str`/
`list_dict` are documentation-only.
- Extending to a new provider = adding a key to `requirement.checks`. Nothing else.
- **No automatic check-existence validation at load time** — a typo'd check id
silently produces a requirement with no findings. Always run the
check-existence cross-check (see Validation).
- In universal files, always set `Provider` on every config constraint so a
guardrail authored for an AWS check never affects Azure/GCP scans of the
same requirement.
## Legacy Schema Reference
Base legacy file structure:
```json
{
"Framework": "FRAMEWORK_NAME",
"Name": "Full Framework Name with Version",
"Version": "X.X",
"Provider": "AWS",
"Description": "Framework description...",
"Requirements": [
{
"Id": "requirement_id",
"Name": "Optional requirement name",
"Description": "Requirement description",
"Attributes": [ ... ],
"Checks": ["check_name_1"],
"ConfigRequirements": [ ... ]
}
]
}
```
### Legacy fields, top level (`Compliance`)
| Field | Type | Required | Notes |
|---|---|---|---|
| `Framework` | string | Yes (non-empty, validated) | Canonical identifier (`CIS`, `ENS`, `NIST-800-53-Revision-5`). |
| `Name` | string | Yes (non-empty, validated) | Human-readable name with version. |
| `Version` | string | Optional in the model — **never leave it empty in practice** | Empty Version silently degrades the `get_check_compliance()` key to `"{Framework}"` (gotcha #4). Must match the version substring in the filename. |
| `Provider` | string | Yes (non-empty, validated) | Upper-cased single provider (`AWS`, `AZURE`, `GCP`, `M365`, ...). One file = one provider. |
| `Description` | string | Yes | Framework scope and purpose. |
| `Requirements` | array | Yes | Requirement objects (below), or `Mitre_Requirement` objects for MITRE files. |
### Legacy fields, per requirement (`Compliance_Requirement`)
| Field | Type | Required | Notes |
|---|---|---|---|
| `Id` | string | Yes | Unique within the framework; follow the source numbering exactly (`1.1`, `A.5.1`, `CCC.Core.CN01.AR01`). |
| `Description` | string | Yes | Verbatim from the source catalog. |
| `Name` | string | No | Optional short title (NIST-style catalogs use it). |
| `Attributes` | array of objects | Yes | Parsed against the Union of attribute classes below; only `Attributes[0]` survives the universal adaptation and drives UI grouping. |
| `Checks` | array of strings | Yes | Check ids automating the requirement; `[]` = manual. |
| `ConfigRequirements` | array | No | Guardrails; `Provider` is omitted (the file is single-provider). |
MITRE files use `Mitre_Requirement` instead, which adds `Tactics`,
`SubTechniques`, `Platforms`, `TechniqueURL` at the requirement top level.
### Attribute shapes per framework family
Unlike universal (schema in-file), a legacy requirement's `Attributes` must
match one of the Pydantic classes registered in
`Compliance_Requirement.Attributes` — a shape matching no class **silently
falls through to Generic**, dropping its specific fields. The most common
shapes (full field sets in `compliance_models.py`):
### CIS — `cis_{version}_{provider}`
```json
{
"Section": "1 Identity and Access Management",
"SubSection": "Optional subsection",
"Profile": "Level 1",
"AssessmentStatus": "Automated",
"Description": "...", "RationaleStatement": "...", "ImpactStatement": "...",
"RemediationProcedure": "...", "AuditProcedure": "...",
"AdditionalInformation": "...", "DefaultValue": "...", "References": "https://..."
}
```
`Profile`: `Level 1|Level 2|E3 Level 1|E3 Level 2|E5 Level 1|E5 Level 2`.
`AssessmentStatus`: `Automated|Manual`.
### ENS — `ens_rd2022_{provider}`
```json
{
"IdGrupoControl": "op.acc.1", "Marco": "operacional",
"Categoria": "control de acceso", "DescripcionControl": "...",
"Nivel": "alto", "Tipo": "requisito",
"Dimensiones": ["trazabilidad", "autenticidad"],
"ModoEjecucion": "automatico", "Dependencias": []
}
```
`Nivel`: `opcional|bajo|medio|alto`. `Tipo`: `refuerzo|requisito|recomendacion|medida`.
`Dimensiones`: `confidencialidad|integridad|trazabilidad|autenticidad|disponibilidad`.
### ISO 27001 — `iso27001_{year}_{provider}`
```json
{
"Category": "A.5 Organizational controls",
"Objetive_ID": "A.5.1", "Objetive_Name": "Policies for information security",
"Check_Summary": "Summary of what is being checked"
}
```
Note: `Objetive_ID` / `Objetive_Name` use this exact (mis)spelling.
### MITRE ATT&CK — `mitre_attack_{provider}` (separate requirement model)
```json
{
"Name": "Exploit Public-Facing Application", "Id": "T1190",
"Tactics": ["Initial Access"], "SubTechniques": [],
"Platforms": ["IaaS"], "Description": "...",
"TechniqueURL": "https://attack.mitre.org/techniques/T1190/",
"Checks": ["guardduty_is_enabled"],
"Attributes": [
{"AWSService": "Amazon GuardDuty", "Category": "Detect",
"Value": "Minimal", "Comment": "..."}
]
}
```
`AzureService`/`GCPService` for the other providers. `Category`:
`Detect|Protect|Respond`. `Value`: `Minimal|Partial|Significant`.
### CCC — `ccc_{provider}`
```json
{
"FamilyName": "Data", "FamilyDescription": "...",
"Se...
© prowler-cloud · Apache-2.0 · prowler-cloud/prowler