diff --git a/.github/workflows/reference-data-refresh.yml b/.github/workflows/reference-data-refresh.yml index 3288689..6121fd9 100644 --- a/.github/workflows/reference-data-refresh.yml +++ b/.github/workflows/reference-data-refresh.yml @@ -28,7 +28,9 @@ jobs: - name: Install requirements run: python -m pip install --quiet -r data_validation/requirements.txt - - name: Regenerate ATLAS and CWE tables + - name: Regenerate the reference tables + env: + GITHUB_TOKEN: ${{ github.token }} run: python data_validation/reference_data/update_reference_data.py - name: Run the checks against the new tables @@ -50,11 +52,11 @@ jobs: git config user.email "41898282+github-actions[bot]@users.noreply.github.com" git switch -c "$branch" git add data_validation/reference_data - git commit -m "reference_data: refresh MITRE ATLAS and CWE tables" + git commit -m "reference_data: refresh the externally maintained tables" git push --force origin "$branch" - versions=$(grep -E '^\| (MITRE ATLAS|CWE) ' data_validation/reference_data/SOURCES.md | cut -d'|' -f2,4) + versions=$(grep -E '^\| (MITRE ATLAS|CWE|AIBOM Generator fields) ' data_validation/reference_data/SOURCES.md | cut -d'|' -f2,4) { - echo "The monthly refresh regenerated the MITRE ATLAS and CWE tables." + echo "The monthly refresh regenerated the MITRE ATLAS, CWE and AIBOM Generator field tables." echo echo "Versions: $versions" echo diff --git a/data_validation/reference_data/SOURCES.md b/data_validation/reference_data/SOURCES.md index b14d7d0..07969cb 100644 --- a/data_validation/reference_data/SOURCES.md +++ b/data_validation/reference_data/SOURCES.md @@ -11,10 +11,11 @@ Lookup tables the validators check identifiers against. | Language subtags | `language_subtags.csv` | 2026-09-17 | IANA Language Subtag Registry, `https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry` (languages, scripts, regions) | | NIST AI 100-2 | `nist_ai_100_2.csv` | E2025 | NIST AI 100-2e2025, *Adversarial Machine Learning: A Taxonomy and Terminology of Attacks and Mitigations*, Taxonomy Index, https://doi.org/10.6028/NIST.AI.100-2e2025. The 30 `NISTAML.*` identifiers from its Taxonomy Index and section text (NISTAML.016 and .017 appear only in §3.4.1) | | CWE | `cwe_ids.csv` | 4.20 | `https://cwe.mitre.org/data/xml/cwec_latest.xml.zip` (weaknesses, categories and views) | +| AIBOM Generator fields | `aibom_fields.csv` | aibom-generator@45851cb96dbe | OWASP AIBOM Generator `src/models/field_registry.json`, `https://github.com/GenAI-Security-Project/aibom-generator`: one row per field id, with the CycloneDX path the generator writes it to (`none` when it never writes the field to the BOM), its inclusion rule and its tier | `owasp_top10.csv` is maintained by hand. The 2026 LLM list renumbered the entries (LLM03 was Supply Chain in 2025 and is Excessive Agency in 2026), so IDs always carry the edition year; `equivalent_2025` gives the 2025 ID each 2026 entry continues (LLM08:2026 Hidden Context Exposure broadens LLM07:2025 System Prompt Leakage). OWASP writes the Agentic IDs without a year (ASI01); this repository adds `:2026` so a future edition cannot collide. -Regenerate the ATLAS, CWE, SPDX and language tables with `python update_reference_data.py`; it fills in the Version column. Do not edit those CSVs by hand. `nist_ai_100_2.csv` and `owasp_top10.csv` are maintained by hand when a new edition is published. +Regenerate the ATLAS, CWE, SPDX, language and AIBOM field tables with `python update_reference_data.py`; it fills in the Version column. Do not edit those CSVs by hand. `nist_ai_100_2.csv` and `owasp_top10.csv` are maintained by hand when a new edition is published. `datasets/_shared/dsgai_taxonomy.json` is the DSGAI list the validators use. `dsgai_entries.json` is kept because the Turkish prompt-injection validator reads it. diff --git a/data_validation/reference_data/aibom_fields.csv b/data_validation/reference_data/aibom_fields.csv new file mode 100644 index 0000000..dc784ad --- /dev/null +++ b/data_validation/reference_data/aibom_fields.csv @@ -0,0 +1,51 @@ +field_id,cyclonedx_path,rule,tier,description +attention_head_count,$.components[0].properties,include_if_available,supplementary,Number of attention heads in the model +attention_head_count_kv,$.components[0].properties,include_if_available,supplementary,Number of Key-Value attention heads +autonomyType,$.metadata.properties,include_if_available,supplementary,Level of autonomy or human involvement required +block_count,$.components[0].properties,include_if_available,supplementary,Number of transformer blocks or layers +bomFormat,$.bomFormat,always_include,critical,Format identifier for the SBOM +component_version,$.components[0].version,always_include,critical,Version of the component +context_length,$.components[0].properties,include_if_available,supplementary,Maximum context length or sequence length supported +datasets,$.component.modelCard.modelParameters.datasets,include_if_available,important,Datasets used for training +description,$.components[0].description,include_if_available,important,Description of the AI model +domain,$.metadata.properties,include_if_available,supplementary,Domain or field of application +downloadLocation,$.component.externalReferences,include_if_available,important,URL to download the model +embedding_length,$.components[0].properties,include_if_available,supplementary,Vector length of the token embeddings +energyConsumption,$.metadata.properties,include_if_available,important,Energy consumption information +energyQuantity,$.metadata.properties,include_if_available,supplementary,Quantitative energy consumption data +energyUnit,$.metadata.properties,include_if_available,supplementary,Unit of measurement for energy consumption +ethicalConsiderations,$.component.modelCard.considerations.ethicalConsiderations,include_if_available,important,Ethical considerations and fairness assessments +external_references,$.component.externalReferences,include_if_available,supplementary,Additional external references +feed_forward_length,$.components[0].properties,include_if_available,supplementary,Dimensionality of the feed-forward network +hyperparameter,$.metadata.properties,include_if_available,important,Key hyperparameters of the model architecture +informationAboutApplication,$.metadata.properties,include_if_available,supplementary,Information about intended applications +informationAboutTraining,$.metadata.properties,include_if_available,supplementary,Information about the training process +intendedUse,$.component.modelCard.considerations.useCases,include_if_available,important,Intended use cases for the model +licenses,$.components[0].licenses,include_if_available,important,License information for the model +metric,$.metadata.properties,include_if_available,supplementary,Performance metrics and evaluation results +metricDecisionThreshold,$.metadata.properties,include_if_available,supplementary,Decision thresholds for metrics +modelDataPreprocessing,$.metadata.properties,include_if_available,supplementary,Data preprocessing information +modelExplainability,$.metadata.properties,include_if_available,supplementary,Information about model explainability +model_file_size,$.components[0].properties,include_if_available,supplementary,Total size in bytes of the model weight files in the repository +name,$.components[0].name,always_include,critical,Name of the AI model component +paper,none,include_if_present,supplementary,Research paper associated with the model +primaryPurpose,$.component.modelCard.modelParameters.task,include_if_available,critical,Primary purpose or task of the AI model +purl,$.components[0].purl,include_if_available,important,Package URL identifier +quantization_file_type,$.components[0].properties,include_if_available,supplementary,Enum or integer identifier for the quantization bit-precision (e.g. Q4_K_M) +quantization_version,$.components[0].properties,include_if_available,supplementary,Version or specification identifier of the quantization format +rope_dimension_count,$.components[0].properties,include_if_available,supplementary,Number of dimensions for Rotary Position Embedding (RoPE) +runtime_requirement,$.components[0].properties,include_if_available,supplementary,Runtime needed to execute the model based on its weight format: 'python' (loadable from a Python ML stack such as transformers/PyTorch) or 'llm-stack' (requires an LLM inference stack such as llama.cpp/Ollama for GGUF/GGML weights) +safetyRiskAssessment,$.metadata.properties,include_if_available,important,Safety and risk assessment information +serialNumber,$.serialNumber,always_include,critical,Unique identifier for this SBOM instance +specVersion,$.specVersion,always_include,critical,CycloneDX specification version +standardCompliance,$.metadata.properties,include_if_available,supplementary,Standards or regulations the model complies with +suppliedBy,$.component.supplier,include_if_available,critical,Organization or individual that supplied the model +technicalLimitations,$.component.modelCard.considerations.technicalLimitations,include_if_available,important,Known limitations of the model +tokenizer_class,$.components[0].properties,include_if_available,supplementary,The specific tokenizer class or method used +type,$.components[0].type,always_include,critical,Type of component (machine-learning-model) +typeOfModel,$.components[0].modelCard.modelParameters.modelArchitecture,include_if_available,important,Type or architecture of the model +useSensitivePersonalInformation,$.metadata.properties,include_if_available,supplementary,Information about use of sensitive personal data +vcs,none,include_if_present,supplementary,Version control system URL +version,$.version,always_include,critical,Version of this SBOM document +vocab_size,$.components[0].properties,include_if_available,supplementary,Expected size of the model's vocabulary +website,none,include_if_present,supplementary,Model website or documentation URL diff --git a/data_validation/reference_data/update_reference_data.py b/data_validation/reference_data/update_reference_data.py index c90fbde..e8b63ff 100644 --- a/data_validation/reference_data/update_reference_data.py +++ b/data_validation/reference_data/update_reference_data.py @@ -1,12 +1,14 @@ """ Regenerates the lookup tables that track an external release: MITRE ATLAS, -CWE, the SPDX License List and the IANA Language Subtag Registry. +CWE, the SPDX License List, the IANA Language Subtag Registry and the OWASP +AIBOM Generator field registry. python update_reference_data.py # all of them python update_reference_data.py --atlas # mitre_atlas_techniques.csv python update_reference_data.py --cwe # cwe_ids.csv python update_reference_data.py --spdx # spdx_licenses.csv python update_reference_data.py --languages # language_subtags.csv + python update_reference_data.py --aibom # aibom_fields.csv Run it when one of them publishes a new release (the reference-data-refresh workflow does so monthly), and commit the regenerated CSVs together with the @@ -20,6 +22,7 @@ import csv import io import json +import os import re import sys import urllib.request @@ -42,11 +45,18 @@ CWE_URL = "https://cwe.mitre.org/data/xml/cwec_latest.xml.zip" SPDX_URL = "https://raw.githubusercontent.com/spdx/license-list-data/main/json/licenses.json" IANA_SUBTAGS_URL = "https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry" +AIBOM_REPO = "GenAI-Security-Project/aibom-generator" +AIBOM_HEAD_URL = f"https://api.github.com/repos/{AIBOM_REPO}/commits/main" +AIBOM_REGISTRY_URL = f"https://raw.githubusercontent.com/{AIBOM_REPO}/%s/src/models/field_registry.json" SOURCES = HERE / "SOURCES.md" def fetch(url: str) -> bytes: - with urllib.request.urlopen(url, timeout=60) as resp: # noqa: S310 - fixed https URLs + request = urllib.request.Request(url) # noqa: S310 - fixed https URLs + token = os.environ.get("GITHUB_TOKEN") + if token and url.startswith("https://api.github.com/"): + request.add_header("Authorization", f"Bearer {token}") + with urllib.request.urlopen(request, timeout=60) as resp: # noqa: S310 - fixed https URLs return resp.read() @@ -156,13 +166,28 @@ def update_languages() -> None: print(f"language_subtags.csv: {len(rows)} subtags (IANA registry {file_date})") +def update_aibom() -> None: + """The fields the OWASP AIBOM Generator can write, from its field_registry.json at the current main commit.""" + commit = json.loads(fetch(AIBOM_HEAD_URL))["sha"] + fields = json.loads(fetch(AIBOM_REGISTRY_URL % commit))["fields"] + rows = [{"field_id": fid, "cyclonedx_path": f["aibom_generation"]["location"], "rule": f["aibom_generation"]["rule"], + "tier": f["tier"], "description": f["description"]} for fid, f in sorted(fields.items())] + with open(HERE / "aibom_fields.csv", "w", newline="", encoding="utf-8") as fh: + w = csv.DictWriter(fh, fieldnames=["field_id", "cyclonedx_path", "rule", "tier", "description"], lineterminator="\n") + w.writeheader() + w.writerows(rows) + set_version("AIBOM Generator fields", f"aibom-generator@{commit[:12]}") + print(f"aibom_fields.csv: {len(rows)} fields (aibom-generator {commit[:12]})") + + def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description="Regenerate the externally maintained reference tables") - for name in ("atlas", "cwe", "spdx", "languages"): + for name in ("atlas", "cwe", "spdx", "languages", "aibom"): parser.add_argument(f"--{name}", action="store_true") args = parser.parse_args(argv) - every = not (args.atlas or args.cwe or args.spdx or args.languages) - for name, update in (("atlas", update_atlas), ("cwe", update_cwe), ("spdx", update_spdx), ("languages", update_languages)): + every = not (args.atlas or args.cwe or args.spdx or args.languages or args.aibom) + for name, update in (("atlas", update_atlas), ("cwe", update_cwe), ("spdx", update_spdx), ("languages", update_languages), + ("aibom", update_aibom)): if every or getattr(args, name): update() return 0 diff --git a/data_validation/requirements-dev.txt b/data_validation/requirements-dev.txt index 777a494..aa72e38 100644 --- a/data_validation/requirements-dev.txt +++ b/data_validation/requirements-dev.txt @@ -1,6 +1,10 @@ # Hash-pinned lock generated from requirements-dev.in by data_validation/update_locks.py # (uv pip compile --universal --generate-hashes --python-version 3.11). # Do not edit by hand: change requirements-dev.in and rerun the script. +agent-evidence-vectors==0.24.0 \ + --hash=sha256:bc8c5785dc9768676361151a4ca2fb4dc1d9bd5a22a67381f6db7adda014539d \ + --hash=sha256:fa1c4b804f700a0f71f1a1776978546d9df571b4e5a451b58220478f75e3b6d3 + # via -r requirements.in arrow==1.4.0 \ --hash=sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205 \ --hash=sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7 diff --git a/data_validation/requirements.in b/data_validation/requirements.in index 44a7ce1..fed5885 100644 --- a/data_validation/requirements.in +++ b/data_validation/requirements.in @@ -5,3 +5,7 @@ jsonschema[format-nongpl]>=4.18.0 pytest>=7.0.0 # Only for reference_data/update_reference_data.py (refreshing the ATLAS table) pyyaml>=6.0 +# Signed conformance records and their reference verifier, replayed by +# validators/evidence_mapping_check.py for mapping rows that cite test_records. +# Exact pin: a new corpus release can change a verdict, so Dependabot proposes each bump. +agent-evidence-vectors==0.24.0 diff --git a/data_validation/requirements.txt b/data_validation/requirements.txt index 47c5cd0..2832f34 100644 --- a/data_validation/requirements.txt +++ b/data_validation/requirements.txt @@ -1,6 +1,10 @@ # Hash-pinned lock generated from requirements.in by data_validation/update_locks.py # (uv pip compile --universal --generate-hashes --python-version 3.11). # Do not edit by hand: change requirements.in and rerun the script. +agent-evidence-vectors==0.24.0 \ + --hash=sha256:bc8c5785dc9768676361151a4ca2fb4dc1d9bd5a22a67381f6db7adda014539d \ + --hash=sha256:fa1c4b804f700a0f71f1a1776978546d9df571b4e5a451b58220478f75e3b6d3 + # via -r requirements.in arrow==1.4.0 \ --hash=sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205 \ --hash=sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7 diff --git a/data_validation/run_all_checks.py b/data_validation/run_all_checks.py index 294cb02..c0f9940 100644 --- a/data_validation/run_all_checks.py +++ b/data_validation/run_all_checks.py @@ -10,8 +10,9 @@ 2. Shared checks (data_validation/validators/) on every data file: schema (for files no dataset validator covers), DSGAI IDs, CVE/CWE/ATLAS OWASP Top 10 and NIST AI 100-2 IDs, CVSS scores and ratings, dates, - SPDX licences and BCP 47 language tags, anonymization patterns and - duplicates. Errors fail the run; + SPDX licences and BCP 47 language tags, mapping rows that cite + published test records, mapping rows keyed on AIBOM Generator field ids, + anonymization patterns and duplicates. Errors fail the run; heuristic warnings (anonymization, near-duplicates, retired IDs) are counted, and printed with --verbose. @@ -36,11 +37,13 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) from validators import ( # noqa: E402 + aibom_field_check, anonymization_scanner, crossref_validator, date_check, dedup_checker, dsgai_mapping_check, + evidence_mapping_check, metadata_check, schema_validator, severity_check, @@ -158,6 +161,8 @@ def shared_checks(dataset: Path, datasets_root: Path) -> tuple[int, list[Finding findings += severity_check.check_data(path, data) findings += date_check.check_data(path, data) findings += metadata_check.check_data(path, data) + findings += evidence_mapping_check.check_data(path, data) + findings += aibom_field_check.check_data(path, data) findings += anonymization_scanner.check_data(path, data) records, load_errors = dedup_checker.load_records(files) findings += load_errors + dedup_checker.check_records(records) @@ -225,7 +230,10 @@ def main(argv: list[str] | None = None) -> int: checked_files = errors = warnings = 0 if not args.no_shared: - print("\nShared checks (schema, DSGAI, CVE/CWE/ATLAS/OWASP/NIST IDs, CVSS, dates, licences, languages, anonymization, duplicates):") + print( + "\nShared checks (schema, DSGAI, CVE/CWE/ATLAS/OWASP/NIST IDs, CVSS, dates, licences, languages," + " test records, anonymization, duplicates):" + ) for dataset in datasets: n, findings = shared_checks(dataset, datasets_root) if not n: diff --git a/data_validation/tests/test_aibom_field_check.py b/data_validation/tests/test_aibom_field_check.py new file mode 100644 index 0000000..81e977f --- /dev/null +++ b/data_validation/tests/test_aibom_field_check.py @@ -0,0 +1,133 @@ +"""Tests for aibom_field_check.py, against the pinned AIBOM Generator field table.""" +from __future__ import annotations + +import json +import sys +from pathlib import Path + +import pytest + +sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) + +from validators import aibom_field_check as ab # noqa: E402 +from validators._common import DATASETS_ROOT, ERROR, iter_data_files # noqa: E402 + +P = Path("entry.json") + + +def row(field, control_id="MAP 2.3"): + return {"framework_alignments": [ + {"framework": "NIST AI RMF 1.0", "control_id": control_id, "alignment_status": "satisfied", "aibom_field": field}, + ]} + + +def test_objects_outside_framework_alignments_are_not_checked(): + assert ab.check_data(P, {"controls": [{"control_id": "PR.DS-05", "alignment_status": "satisfied"}]}) == [] + + +def test_a_mapping_row_with_neither_key_fails(): + data = {"framework_alignments": [ + {"control_id": "A.8.2", "aibom_field": "datasets"}, + {"control_id": "PR.DS-05", "alignment_status": "satisfied"}, + ]} + [f] = ab.check_data(P, data) + assert f.level == ERROR and "neither aibom_field nor aibom_field_none" in f.message + assert f.location == "/framework_alignments/1" + + +def test_an_unkeyed_row_is_found_at_any_depth(): + data = {"entries": [{"framework_alignments": ["not-an-object", {"control_id": "GOVERN 1.1"}]}]} + assert [f.location for f in ab.check_data(P, data)] == ["/entries/0/framework_alignments/1"] + + +def test_every_risk_assessment_row_is_keyed_or_carries_a_reason(): + dataset = DATASETS_ROOT / "riskassessment_dataset" + rows = [ + row + for path in [*sorted((dataset / "entries").glob("*.json")), dataset / "example.json"] + for row in json.loads(path.read_text(encoding="utf-8"))["framework_alignments"] + ] + assert rows and all((ab.KEY in r) != (ab.NONE_KEY in r) for r in rows) + + +@pytest.mark.parametrize("field", ["datasets", "metric", "safetyRiskAssessment", "bomFormat"]) +def test_a_registry_field_passes(field): + assert ab.check_data(P, row(field)) == [] + + +def test_unknown_field_fails_with_a_suggestion(): + [f] = ab.check_data(P, row("dataset")) + assert f.level == ERROR and "'dataset' is not a field" in f.message and "did you mean 'datasets'" in f.message + assert f.location == "/framework_alignments/0/aibom_field" + + +def test_unknown_field_without_a_near_match_fails_without_a_suggestion(): + [f] = ab.check_data(P, row("zzzzzz")) + assert f.level == ERROR and "did you mean" not in f.message + + +@pytest.mark.parametrize("field", ["paper", "vcs", "website"]) +def test_a_field_the_generator_never_writes_fails(field): + [f] = ab.check_data(P, row(field)) + assert f.level == ERROR and "never writes" in f.message + + +@pytest.mark.parametrize("value", [None, 3, ["datasets"], {"id": "datasets"}]) +def test_a_non_string_value_fails(value): + [f] = ab.check_data(P, row(value)) + assert f.level == ERROR and "expected a field id" in f.message + + +def test_every_cited_row_is_found_at_any_depth(): + data = {"a": row("datasets"), "b": [row("nope"), row("also-nope")]} + assert [f.location for f in ab.check_data(P, data)] == [ + "/b/0/framework_alignments/0/aibom_field", + "/b/1/framework_alignments/0/aibom_field", + ] + + +def test_table_matches_the_registry_shape(): + fields = ab.generator_fields() + assert len(fields) >= 50 and {"datasets", "metric", "safetyRiskAssessment"} <= set(fields) + assert all(r["rule"] and r["tier"] and r["cyclonedx_path"] for r in fields.values()) + assert {k for k, r in fields.items() if r["cyclonedx_path"] == ab.NOT_WRITTEN} == {"paper", "vcs", "website"} + + +def test_every_keyed_row_in_the_datasets_passes(): + findings = [] + for path in iter_data_files(DATASETS_ROOT): + findings += ab.check_data(path, json.loads(path.read_text(encoding="utf-8"))) + assert findings == [] + + +@pytest.mark.parametrize("reason", ab.REASONS) +def test_a_recorded_reason_passes(reason): + data = {"framework_alignments": [{"control_id": "PR.AC-04", "alignment_status": "satisfied", "aibom_field_none": reason}]} + assert ab.check_data(P, data) == [] + + +@pytest.mark.parametrize("reason", ["", "deployment", "none", None, 3]) +def test_an_unknown_reason_fails_and_lists_the_reasons(reason): + data = {"framework_alignments": [{"control_id": "PR.AC-04", "aibom_field_none": reason}]} + [f] = ab.check_data(P, data) + assert f.level == ERROR and "deployment-control, runtime-behaviour, no-registry-field" in f.message + assert f.location == "/framework_alignments/0/aibom_field_none" + + +def test_a_row_with_both_keys_fails(): + data = {"framework_alignments": [{"control_id": "A.8.2", "aibom_field": "datasets", "aibom_field_none": "deployment-control"}]} + [f] = ab.check_data(P, data) + assert f.level == ERROR and "both" in f.message and f.location == "/framework_alignments/0" + + +def test_reasons_match_the_dataset_schema(): + schema = json.loads((DATASETS_ROOT / "riskassessment_dataset" / "schema.json").read_text(encoding="utf-8")) + row_props = schema["properties"]["framework_alignments"]["items"]["properties"] + assert tuple(row_props[ab.NONE_KEY]["enum"]) == ab.REASONS + + +def test_cli_on_a_file(tmp_path, capsys): + path = tmp_path / "entry.json" + path.write_text(json.dumps(row("paper")), encoding="utf-8") + assert ab.main(["--file", str(path)]) == 1 + assert "never writes 'paper'" in capsys.readouterr().out diff --git a/data_validation/tests/test_evidence_mapping_check.py b/data_validation/tests/test_evidence_mapping_check.py new file mode 100644 index 0000000..4e9892d --- /dev/null +++ b/data_validation/tests/test_evidence_mapping_check.py @@ -0,0 +1,106 @@ +"""Tests for evidence_mapping_check.py, against the pinned agent-evidence-vectors corpora.""" +from __future__ import annotations + +import sys +from pathlib import Path + +import pytest + +sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) + +from validators import evidence_mapping_check as em # noqa: E402 +from validators._common import ERROR, WARN # noqa: E402 + +P = Path("entry.json") + + +def row(control_id="MCP03", status="satisfied", **records): + cited = {"package": "agent-evidence-vectors", "corpus": "vectors-mcp-owasp", **records} + return {"framework_alignments": [ + {"framework": "OWASP MCP Top 10", "control_id": control_id, "alignment_status": status, "test_records": cited}, + ]} + + +def test_rows_without_test_records_are_not_checked(): + assert em.check_data(P, {"framework_alignments": [{"control_id": "PR.DS-05", "alignment_status": "satisfied"}]}) == [] + + +def test_cited_requirement_that_tests_the_control_passes(): + assert em.check_data(P, row(requirement="MCPVS-1")) == [] + + +def test_requirement_that_tests_another_control_fails(): + [f] = em.check_data(P, row(control_id="MCP01", requirement="MCPVS-1")) + assert f.level == ERROR and "MCPVS-1 tests MCP03, not MCP01" in f.message + assert f.location == "/framework_alignments/0/test_records" + + +def test_unknown_requirement_fails(): + [f] = em.check_data(P, row(requirement="MCPVS-999")) + assert f.level == ERROR and "not in the vectors-mcp-owasp registry" in f.message + + +def test_withdrawn_requirement_fails(monkeypatch): + monkeypatch.setattr(em, "registry", lambda corpus: {"MCPVS-1": {"id": "MCPVS-1", "status": "withdrawn", "top10": ["MCP03"]}}) + [f] = em.check_data(P, row(requirement="MCPVS-1")) + assert f.level == ERROR and "withdrawn" in f.message + + +def test_corpus_not_shipped_fails(): + data = row() + data["framework_alignments"][0]["test_records"]["corpus"] = "vectors-does-not-exist" + [f] = em.check_data(P, data) + assert f.level == ERROR and "ships no corpus 'vectors-does-not-exist'" in f.message + + +def test_corpus_without_a_reference_reader_fails(): + # Shipped, but the package's reference verifier has no reader for it, so nothing is judged. + data = row(control_id="DE.AE-02") + data["framework_alignments"][0]["test_records"]["corpus"] = "vectors-delegation-lifecycle" + [f] = em.check_data(P, data) + assert f.level == ERROR and "does not replay clean" in f.message + + +def test_failing_replay_fails(monkeypatch): + monkeypatch.setattr(em, "replay", lambda corpus: (False, "FAIL v0485d4e3a7045da5 reject")) + [f] = em.check_data(P, row(requirement="MCPVS-1")) + assert f.level == ERROR and "FAIL v0485d4e3a7045da5" in f.message + + +@pytest.mark.parametrize("status", ["missing", "not_applicable"]) +def test_records_on_an_unsupported_row_warn(status): + [f] = em.check_data(P, row(status=status, requirement="MCPVS-1")) + assert f.level == WARN and status in f.message + + +@pytest.mark.parametrize("cited", [ + "vectors-mcp-owasp", + {"corpus": "vectors-mcp-owasp"}, + {"package": "other-package", "corpus": "vectors-mcp-owasp"}, + {"package": "agent-evidence-vectors"}, +]) +def test_malformed_citation_fails(cited): + [f] = em.check_data(P, {"framework_alignments": [{"control_id": "MCP03", "test_records": cited}]}) + assert f.level == ERROR and "expected" in f.message + + +def test_package_not_installed_fails(monkeypatch): + monkeypatch.setattr(em, "package_version", lambda: None) + [f] = em.check_data(P, row(requirement="MCPVS-1")) + assert f.level == ERROR and "is not installed" in f.message + + +def test_each_corpus_replays_once(): + em.replay.cache_clear() + em.check_data(P, {"a": row(requirement="MCPVS-1"), "b": row(requirement="MCPVS-2")}) + info = em.replay.cache_info() + assert info.misses == 1 and info.hits == 1 + + +def test_cli_on_a_file(tmp_path, capsys): + import json + + path = tmp_path / "entry.json" + path.write_text(json.dumps(row(control_id="MCP01", requirement="MCPVS-1")), encoding="utf-8") + assert em.main(["--file", str(path)]) == 1 + assert "MCPVS-1 tests MCP03, not MCP01" in capsys.readouterr().out diff --git a/data_validation/validators/aibom_field_check.py b/data_validation/validators/aibom_field_check.py new file mode 100644 index 0000000..e78e0bb --- /dev/null +++ b/data_validation/validators/aibom_field_check.py @@ -0,0 +1,162 @@ +""" +Checks that a framework mapping row keyed on an AIBOM field names a field the +OWASP AIBOM Generator can actually write. + +A row in framework_alignments (or any object with a "control_id") may carry + + "aibom_field": "datasets" + +an id from the generator's src/models/field_registry.json. The row then says +which field of a generated CycloneDX AIBOM evidences the control. The ids come +from reference_data/aibom_fields.csv, a table regenerated from the registry at +a recorded commit (see reference_data/SOURCES.md). A row that no field +evidences carries instead + + "aibom_field_none": "deployment-control" + +with one of the reasons in REASONS (defined in the dataset's schema.json). + +ERROR: the value is not a string; the id is not in the registry; the registry + lists the field with no CycloneDX location, so the generator never + writes it into the BOM; the reason is not one of REASONS; the row + carries both keys; a row in a framework_alignments list carries + neither, so it is not keyed. +The inclusion rule and tier are not judged: a field written only +"include_if_available" is still a valid key, because the generator emits it +whenever the model's source has the data. + +Usage: + python aibom_field_check.py --file ../../datasets/riskassessment_dataset/entries/X.json + python aibom_field_check.py # every dataset +""" +from __future__ import annotations + +import argparse +import csv +import difflib +import sys +from functools import cache +from pathlib import Path +from typing import Any + +if __package__ in (None, ""): + sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) + +from validators._common import ( # noqa: E402 + DATASETS_ROOT, + ERROR, + REFERENCE_DIR, + Finding, + add_target_args, + ensure_utf8_stdout, + load_json, + print_findings, + resolve_targets, +) + +CHECK = "aibom" +KEY = "aibom_field" +NONE_KEY = "aibom_field_none" +REASONS = ("deployment-control", "runtime-behaviour", "no-registry-field") +TABLE = "aibom_fields.csv" +NOT_WRITTEN = "none" + + +@cache +def generator_fields() -> dict[str, dict[str, str]]: + """Field id to its registry row (cyclonedx_path, rule, tier, description).""" + with open(REFERENCE_DIR / TABLE, newline="", encoding="utf-8") as fh: + return {row["field_id"]: row for row in csv.DictReader(fh)} + + +def iter_keyed_rows(obj: Any, pointer: str = ""): + """(pointer, row) for every object that carries aibom_field or aibom_field_none.""" + if isinstance(obj, dict): + if KEY in obj or NONE_KEY in obj: + yield pointer, obj + for k, v in obj.items(): + yield from iter_keyed_rows(v, f"{pointer}/{k}") + elif isinstance(obj, list): + for i, v in enumerate(obj): + yield from iter_keyed_rows(v, f"{pointer}/{i}") + + +def iter_alignment_rows(obj: Any, pointer: str = ""): + """(pointer, row) for every object in a framework_alignments list, at any depth.""" + if isinstance(obj, dict): + for k, v in obj.items(): + if k == "framework_alignments" and isinstance(v, list): + for i, row in enumerate(v): + if isinstance(row, dict): + yield f"{pointer}/{k}/{i}", row + yield from iter_alignment_rows(v, f"{pointer}/{k}") + elif isinstance(obj, list): + for i, v in enumerate(obj): + yield from iter_alignment_rows(v, f"{pointer}/{i}") + + +def check_coverage(path: Path, data: Any) -> list[Finding]: + message = f"the mapping row carries neither {KEY} nor {NONE_KEY}" + return [ + Finding(ERROR, CHECK, path, pointer, message) + for pointer, row in iter_alignment_rows(data) + if KEY not in row and NONE_KEY not in row + ] + + +def check_reason(path: Path, pointer: str, row: dict) -> list[Finding]: + reason = row[NONE_KEY] + if reason in REASONS: + return [] + allowed = ", ".join(REASONS) + return [Finding(ERROR, CHECK, path, f"{pointer}/{NONE_KEY}", f"{reason!r} is not a reason; expected one of {allowed}")] + + +def check_row(path: Path, pointer: str, row: dict) -> list[Finding]: + if KEY in row and NONE_KEY in row: + return [Finding(ERROR, CHECK, path, pointer, f"the row carries both {KEY} and {NONE_KEY}; keep one")] + if NONE_KEY in row: + return check_reason(path, pointer, row) + where = f"{pointer}/{KEY}" + field = row[KEY] + if not isinstance(field, str): + return [Finding(ERROR, CHECK, path, where, "expected a field id from the AIBOM Generator's field_registry.json")] + fields = generator_fields() + entry = fields.get(field) + if entry is None: + near = difflib.get_close_matches(field, fields, n=1) + hint = f"; did you mean {near[0]!r}?" if near else "" + return [Finding(ERROR, CHECK, path, where, f"{field!r} is not a field in the AIBOM Generator's field_registry.json{hint}")] + if entry["cyclonedx_path"] == NOT_WRITTEN: + message = f"the generator never writes {field!r} to its CycloneDX output (no location in the registry)" + return [Finding(ERROR, CHECK, path, where, message)] + return [] + + +def check_data(path: Path, data: Any) -> list[Finding]: + keyed = [f for pointer, row in iter_keyed_rows(data) for f in check_row(path, pointer, row)] + return keyed + check_coverage(path, data) + + +def check_file(path: Path) -> list[Finding]: + data, err = load_json(path, CHECK) + if err: + return [err] + return check_data(path, data) + + +def main(argv: list[str] | None = None) -> int: + ensure_utf8_stdout() + parser = argparse.ArgumentParser(description="Check mapping rows keyed on AIBOM Generator field ids") + add_target_args(parser) + args = parser.parse_args(argv) + files = resolve_targets(args) + if files is None: + return 2 + findings = [f for p in files for f in check_file(p)] + print(f"Checked {len(files)} file(s)") + return print_findings(findings, DATASETS_ROOT.parent) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/data_validation/validators/evidence_mapping_check.py b/data_validation/validators/evidence_mapping_check.py new file mode 100644 index 0000000..5f9b5a6 --- /dev/null +++ b/data_validation/validators/evidence_mapping_check.py @@ -0,0 +1,187 @@ +""" +Checks that a framework mapping row which cites published test records is +backed by records that exist and pass their reference verifier. + +A row in framework_alignments (or any object with a "control_id") may carry + + "test_records": { + "package": "agent-evidence-vectors", + "corpus": "vectors-mcp-owasp", + "requirement": "MCPVS-1" + } + +naming a conformance corpus of signed accept and reject records shipped in +the agent-evidence-vectors package (pinned in requirements.in), and +optionally one requirement in that corpus's REGISTRY.json. The row's +alignment_status then rests on something a third party can re-run instead +of on the author's word. + +ERROR: the package is not installed; the corpus is not shipped in the + installed version; the requirement is not in the corpus registry or + is withdrawn; the requirement does not list the row's control_id + when the control is one the registry indexes (MCP01-MCP10); or the + corpus does not replay clean under the package's reference verifier + (including a corpus the reference verifier has no reader for). +WARN: test_records on a row whose alignment_status is "missing" or + "not_applicable", where the records cannot support the row. + +Each corpus is replayed once per run, however many rows cite it. + +Usage: + python evidence_mapping_check.py --file ../../datasets/riskassessment_dataset/entries/X.json + python evidence_mapping_check.py # every dataset +""" +from __future__ import annotations + +import argparse +import json +import re +import subprocess +import sys +import tempfile +from functools import cache +from importlib import metadata +from pathlib import Path +from typing import Any + +if __package__ in (None, ""): + sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) + +from validators._common import ( # noqa: E402 + DATASETS_ROOT, + ERROR, + WARN, + Finding, + add_target_args, + ensure_utf8_stdout, + load_json, + print_findings, + resolve_targets, +) + +CHECK = "evidence" +PACKAGE = "agent-evidence-vectors" +MODULE = "agent_evidence_vectors" +KEY = "test_records" +REPLAY_TIMEOUT = 300 +# Control IDs a corpus registry indexes in its "top10" lists. +INDEXED_CONTROL_RE = re.compile(r"^MCP(0[1-9]|10)$") +NO_SUPPORT = {"missing", "not_applicable"} + + +@cache +def package_version() -> str | None: + try: + return metadata.version(PACKAGE) + except metadata.PackageNotFoundError: + return None + + +@cache +def corpora_dir() -> Path | None: + if package_version() is None: + return None + from agent_evidence_vectors.run_vectors import corpora_root + + return Path(corpora_root()) + + +@cache +def registry(corpus: str) -> dict[str, dict] | None: + """Requirement and threat entries of a corpus registry, by id, or None if it has none.""" + root = corpora_dir() + path = root / corpus / "REGISTRY.json" if root else None + if path is None or not path.is_file(): + return None + data = json.loads(path.read_text(encoding="utf-8")) + return {e["id"]: e for section in ("requirements", "threats") for e in data.get(section, []) if "id" in e} + + +@cache +def replay(corpus: str) -> tuple[bool, str]: + """(passed, last output line) for one replay of a shipped corpus by the reference verifier.""" + with tempfile.TemporaryDirectory() as tmp: + try: + proc = subprocess.run( + [sys.executable, "-m", f"{MODULE}.run_vectors", "--corpus", corpus, "--report", str(Path(tmp) / "report.json")], + cwd=tmp, capture_output=True, text=True, encoding="utf-8", errors="replace", + timeout=REPLAY_TIMEOUT, check=False, + ) + except subprocess.TimeoutExpired: + return False, f"replay timed out after {REPLAY_TIMEOUT}s" + lines = (proc.stdout + proc.stderr).strip().splitlines() + return proc.returncode == 0, (lines[-1] if lines else f"exit {proc.returncode}") + + +def iter_cited_rows(obj: Any, pointer: str = ""): + """(pointer, row) for every object that carries test_records.""" + if isinstance(obj, dict): + if KEY in obj: + yield pointer, obj + for k, v in obj.items(): + yield from iter_cited_rows(v, f"{pointer}/{k}") + elif isinstance(obj, list): + for i, v in enumerate(obj): + yield from iter_cited_rows(v, f"{pointer}/{i}") + + +def check_row(path: Path, pointer: str, row: dict) -> list[Finding]: + where = f"{pointer}/{KEY}" + cited = row[KEY] + if not isinstance(cited, dict) or cited.get("package") != PACKAGE or not isinstance(cited.get("corpus"), str): + return [Finding(ERROR, CHECK, path, where, f'expected {{"package": "{PACKAGE}", "corpus": ""}}')] + if package_version() is None: + return [Finding(ERROR, CHECK, path, where, f"{PACKAGE} is not installed (pip install -r requirements.txt)")] + findings: list[Finding] = [] + status = row.get("alignment_status") + if status in NO_SUPPORT: + findings.append(Finding(WARN, CHECK, path, where, f'alignment_status is "{status}"; test records cannot support it')) + corpus = cited["corpus"] + root = corpora_dir() + if root is None or not (root / corpus / "MANIFEST.json").is_file(): + return findings + [Finding(ERROR, CHECK, path, where, f"{PACKAGE} {package_version()} ships no corpus {corpus!r}")] + requirement = cited.get("requirement") + if requirement is not None: + entries = registry(corpus) + entry = entries.get(requirement) if entries else None + if entry is None: + findings.append(Finding(ERROR, CHECK, path, where, f"{requirement!r} is not in the {corpus} registry")) + elif entry.get("status") == "withdrawn": + findings.append(Finding(ERROR, CHECK, path, where, f"{requirement} is withdrawn in the {corpus} registry")) + else: + control = str(row.get("control_id", "")).strip() + if INDEXED_CONTROL_RE.match(control) and control not in entry.get("top10", []): + findings.append(Finding(ERROR, CHECK, path, where, + f"{requirement} tests {', '.join(entry.get('top10', [])) or 'no control'}, not {control}")) + passed, last = replay(corpus) + if not passed: + findings.append(Finding(ERROR, CHECK, path, where, f"{corpus} does not replay clean under the reference verifier: {last}")) + return findings + + +def check_data(path: Path, data: Any) -> list[Finding]: + return [f for pointer, row in iter_cited_rows(data) for f in check_row(path, pointer, row)] + + +def check_file(path: Path) -> list[Finding]: + data, err = load_json(path, CHECK) + if err: + return [err] + return check_data(path, data) + + +def main(argv: list[str] | None = None) -> int: + ensure_utf8_stdout() + parser = argparse.ArgumentParser(description="Check mapping rows that cite published test records") + add_target_args(parser) + args = parser.parse_args(argv) + files = resolve_targets(args) + if files is None: + return 2 + findings = [f for p in files for f in check_file(p)] + print(f"Checked {len(files)} file(s)") + return print_findings(findings, DATASETS_ROOT.parent) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/datasets/riskassessment_dataset/README.md b/datasets/riskassessment_dataset/README.md index f8a9d97..bd97d33 100644 --- a/datasets/riskassessment_dataset/README.md +++ b/datasets/riskassessment_dataset/README.md @@ -47,7 +47,7 @@ Canonical schema: [`schema.json`](./schema.json). Reference entry: [`example.jso | `risks_identified` | yes (≥5) | Per-DSGAI risk entries: `dsgai_id`, `inherent_rating`, `rationale`, optional `residual_rating` + `residual_rationale` | | `existing_controls` | no | Mitigations in place; each with optional tier and `addresses_dsgai[]` | | `control_gaps` | no | Missing/weak mitigations; each with `urgency` (Immediate/Near-term/Strategic) and optional `suggested_remediation` | -| `framework_alignments` | yes (≥4) | Mappings to NIST CSF 2.0, NIST AI RMF, ISO/IEC 42001/27001, OWASP LLM/Agentic Top 10, MITRE ATLAS/ATT&CK, EU AI Act, GDPR, HIPAA, FERPA, PCI DSS 4.0, SOC 2, FedRAMP, Other | +| `framework_alignments` | yes (≥4) | Mappings to NIST CSF 2.0, NIST AI RMF, ISO/IEC 42001/27001, OWASP LLM/Agentic/MCP Top 10, MITRE ATLAS/ATT&CK, EU AI Act, GDPR, HIPAA, FERPA, PCI DSS 4.0, SOC 2, FedRAMP, Other. A row may add `test_records` naming a published corpus of signed test records (see `data_validation/validators/evidence_mapping_check.py`), and `aibom_field` naming the OWASP AIBOM Generator field that evidences the control, or `aibom_field_none` giving the reason no field does (see `data_validation/validators/aibom_field_check.py`) | | `compliance_obligations` | no | Regimes the deployment likely operates under | | `maturity_overall` | no | CMMI-like: Initial/Developing/Defined/Managed/Optimizing | | `source_urls` | no | Optional inspirational references | diff --git a/datasets/riskassessment_dataset/croissant.json b/datasets/riskassessment_dataset/croissant.json index b1a360c..93addb7 100644 --- a/datasets/riskassessment_dataset/croissant.json +++ b/datasets/riskassessment_dataset/croissant.json @@ -89,7 +89,7 @@ "description": "JSON Schema for the records", "contentUrl": "schema.json", "encodingFormat": "application/json", - "sha256": "75ae9981bc08d69ad0916706acf710946f1a892724d78ba8e0ed9f596305e79d" + "sha256": "724c963be0fb198bbf655fbc3c15bd6a6654335e154766644cf9e49f936b1511" }, { "@type": "cr:FileSet", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-browser-productivity-assistant.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-browser-productivity-assistant.json index dc82da1..22f17e5 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-browser-productivity-assistant.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-browser-productivity-assistant.json @@ -40,13 +40,13 @@ {"description": "DLP redacts secret patterns but not semantic content (project codenames, M&A discussion).", "addresses_dsgai": ["DSGAI01", "DSGAI14"], "suggested_remediation": "Add an entity-classifier on prompts to detect sensitive project context; route those prompts to a stricter on-prem model.", "urgency": "Strategic"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "partial"}, - {"framework": "NIST CSF 2.0", "control_id": "PR.AT-01", "control_name": "Awareness and training", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MAP 4.1", "control_name": "Approaches for mapping AI legal and technology risks", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.1.4", "control_name": "Roles, responsibilities, and authorities", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM06:2025", "control_name": "Excessive Agency", "alignment_status": "partial"}, - {"framework": "SOC 2", "control_id": "CC7.2", "control_name": "Monitoring activities", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "PR.AT-01", "control_name": "Awareness and training", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MAP 4.1", "control_name": "Approaches for mapping AI legal and technology risks", "alignment_status": "partial", "aibom_field": "licenses"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.1.4", "control_name": "Roles, responsibilities, and authorities", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM06:2025", "control_name": "Excessive Agency", "alignment_status": "partial", "aibom_field": "autonomyType"}, + {"framework": "SOC 2", "control_id": "CC7.2", "control_name": "Monitoring activities", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "CCPA", "SOC 2"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-clinical-decision-support-rag.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-clinical-decision-support-rag.json index 9df6a3d..ccc04b4 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-clinical-decision-support-rag.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-clinical-decision-support-rag.json @@ -48,15 +48,15 @@ {"description": "Specialty filter on retrieval is static, not adaptive.", "addresses_dsgai": ["DSGAI15"], "suggested_remediation": "Add task-classifier-driven retrieval scoping by clinical-question class.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-01", "control_name": "Data-at-rest is protected", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.10", "control_name": "Privacy risk is evaluated", "alignment_status": "partial"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MANAGE 3.2", "control_name": "AI risks are responded to", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 27001", "control_id": "A.8.11", "control_name": "Data masking", "alignment_status": "satisfied"}, - {"framework": "HIPAA", "control_id": "164.312(a)(1)", "control_name": "Access control standard", "alignment_status": "satisfied"}, - {"framework": "HIPAA", "control_id": "164.312(b)", "control_name": "Audit controls", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"}, - {"framework": "EU AI Act", "control_id": "Annex III", "control_name": "High-risk AI in healthcare", "alignment_status": "partial", "notes": "If deployed for EU patients, classification under high-risk applies."} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-01", "control_name": "Data-at-rest is protected", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.10", "control_name": "Privacy risk is evaluated", "alignment_status": "partial", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MANAGE 3.2", "control_name": "AI risks are responded to", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied", "aibom_field": "safetyRiskAssessment"}, + {"framework": "ISO/IEC 27001", "control_id": "A.8.11", "control_name": "Data masking", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "HIPAA", "control_id": "164.312(a)(1)", "control_name": "Access control standard", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "HIPAA", "control_id": "164.312(b)", "control_name": "Audit controls", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"}, + {"framework": "EU AI Act", "control_id": "Annex III", "control_name": "High-risk AI in healthcare", "alignment_status": "partial", "notes": "If deployed for EU patients, classification under high-risk applies.", "aibom_field": "intendedUse"} ], "compliance_obligations": ["HIPAA", "GDPR", "EU AI Act", "ISO 27001 certification"], "maturity_overall": "Managed", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-contract-review-assistant.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-contract-review-assistant.json index d2865bd..db940e8 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-contract-review-assistant.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-contract-review-assistant.json @@ -42,13 +42,13 @@ {"description": "Counterparty-authored content not consistently tagged in the index.", "addresses_dsgai": ["DSGAI21", "DSGAI06"], "suggested_remediation": "Tag every chunk with its author provenance at ingestion; raise injection-detection sensitivity on counterparty content.", "urgency": "Strategic"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.10", "control_name": "Privacy risk is evaluated", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"}, - {"framework": "GDPR", "control_id": "Art. 5(1)(b)", "control_name": "Purpose limitation", "alignment_status": "satisfied"}, - {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.10", "control_name": "Privacy risk is evaluated", "alignment_status": "partial", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "satisfied", "aibom_field": "datasets"}, + {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"}, + {"framework": "GDPR", "control_id": "Art. 5(1)(b)", "control_name": "Purpose limitation", "alignment_status": "satisfied", "aibom_field": "intendedUse"}, + {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "SOC 2", "UK Data Protection Act 2018"], "maturity_overall": "Managed", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-customer-rag-banking.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-customer-rag-banking.json index d38ae59..e2314cd 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-customer-rag-banking.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-customer-rag-banking.json @@ -50,19 +50,19 @@ {"description": "Adversarial red-team not yet a release gate.", "addresses_dsgai": ["DSGAI21", "DSGAI06"], "suggested_remediation": "Add published red-team corpus to release gate; track refusal stability.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-01", "control_name": "Data-at-rest is protected", "alignment_status": "satisfied"}, - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-01", "control_name": "Identities and credentials are managed", "alignment_status": "satisfied"}, - {"framework": "NIST CSF 2.0", "control_id": "DE.CM-01", "control_name": "The network is monitored", "alignment_status": "partial"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.7", "control_name": "AI system security is evaluated", "alignment_status": "partial"}, - {"framework": "NIST AI RMF 1.0", "control_id": "GOVERN 5.1", "control_name": "Policies and procedures for AI risk", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM01:2025", "control_name": "Prompt Injection", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"}, - {"framework": "GDPR", "control_id": "Art. 35", "control_name": "Data protection impact assessment", "alignment_status": "satisfied"}, - {"framework": "EU AI Act", "control_id": "Art. 26", "control_name": "Obligations of deployers of high-risk AI systems", "alignment_status": "partial"}, - {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-01", "control_name": "Data-at-rest is protected", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-01", "control_name": "Identities and credentials are managed", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "DE.CM-01", "control_name": "The network is monitored", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.7", "control_name": "AI system security is evaluated", "alignment_status": "partial", "aibom_field_none": "no-registry-field"}, + {"framework": "NIST AI RMF 1.0", "control_id": "GOVERN 5.1", "control_name": "Policies and procedures for AI risk", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied", "aibom_field": "safetyRiskAssessment"}, + {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "satisfied", "aibom_field": "datasets"}, + {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM01:2025", "control_name": "Prompt Injection", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"}, + {"framework": "GDPR", "control_id": "Art. 35", "control_name": "Data protection impact assessment", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "EU AI Act", "control_id": "Art. 26", "control_name": "Obligations of deployers of high-risk AI systems", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "CCPA", "SOC 2", "ISO 27001 certification", "EU AI Act", "DORA"], "maturity_overall": "Managed", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-devops-incident-copilot.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-devops-incident-copilot.json index c4dd824..b16bc56 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-devops-incident-copilot.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-devops-incident-copilot.json @@ -44,13 +44,13 @@ {"description": "No tabletop or red-team exercise of indirect-injection-driven destructive remediation.", "addresses_dsgai": ["DSGAI06", "DSGAI17"], "suggested_remediation": "Run quarterly tabletop exercises; document residual residual-risk acceptance from leadership.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied"}, - {"framework": "NIST CSF 2.0", "control_id": "RS.MI-02", "control_name": "Incidents are mitigated", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.6", "control_name": "AI system security is assessed", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.7.3", "control_name": "AI system design and development", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM06:2025", "control_name": "Excessive Agency", "alignment_status": "satisfied"}, - {"framework": "OWASP Agentic Top 10 2026", "control_id": "AGT-02", "control_name": "Blast-radius limiting", "alignment_status": "satisfied"}, - {"framework": "SOC 2", "control_id": "CC7.4", "control_name": "Operational incidents", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "RS.MI-02", "control_name": "Incidents are mitigated", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.6", "control_name": "AI system security is assessed", "alignment_status": "partial", "aibom_field_none": "no-registry-field"}, + {"framework": "ISO/IEC 42001", "control_id": "A.7.3", "control_name": "AI system design and development", "alignment_status": "satisfied", "aibom_field": "informationAboutTraining"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM06:2025", "control_name": "Excessive Agency", "alignment_status": "satisfied", "aibom_field": "autonomyType"}, + {"framework": "OWASP Agentic Top 10 2026", "control_id": "AGT-02", "control_name": "Blast-radius limiting", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "SOC 2", "control_id": "CC7.4", "control_name": "Operational incidents", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["SOC 2", "ISO 27001 certification"], "maturity_overall": "Managed", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-ecommerce-shopping-agent.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-ecommerce-shopping-agent.json index 51cb74b..157c4d6 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-ecommerce-shopping-agent.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-ecommerce-shopping-agent.json @@ -44,13 +44,13 @@ {"description": "No cost-harvesting protection on agent-tool chains.", "addresses_dsgai": ["DSGAI17"], "suggested_remediation": "Per-session tool-call budget caps; alert on cost-harvesting patterns.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-01", "control_name": "Identities and credentials are managed", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.6", "control_name": "AI system security is assessed", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.7.3", "control_name": "AI system design and development", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM05:2025", "control_name": "Improper Output Handling", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM06:2025", "control_name": "Excessive Agency", "alignment_status": "partial"}, - {"framework": "PCI DSS 4.0", "control_id": "Req. 6.4.3", "control_name": "Payment page scripts integrity", "alignment_status": "satisfied"}, - {"framework": "GDPR", "control_id": "Art. 6", "control_name": "Lawfulness of processing", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-01", "control_name": "Identities and credentials are managed", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.6", "control_name": "AI system security is assessed", "alignment_status": "partial", "aibom_field_none": "no-registry-field"}, + {"framework": "ISO/IEC 42001", "control_id": "A.7.3", "control_name": "AI system design and development", "alignment_status": "satisfied", "aibom_field": "informationAboutTraining"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM05:2025", "control_name": "Improper Output Handling", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM06:2025", "control_name": "Excessive Agency", "alignment_status": "partial", "aibom_field": "autonomyType"}, + {"framework": "PCI DSS 4.0", "control_id": "Req. 6.4.3", "control_name": "Payment page scripts integrity", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "GDPR", "control_id": "Art. 6", "control_name": "Lawfulness of processing", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "CCPA", "PCI DSS", "SOC 2"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-email-triage-assistant.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-email-triage-assistant.json index 874bf26..94260ab 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-email-triage-assistant.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-email-triage-assistant.json @@ -43,13 +43,13 @@ {"description": "Attachment-OCR pipeline scans for OCR injection but does not flag low-contrast or hidden-text patterns in PDFs.", "addresses_dsgai": ["DSGAI09", "DSGAI06"], "suggested_remediation": "Add visual-anomaly detection on attachments; flag for human review.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "partial"}, - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "partial"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MAP 4.1", "control_name": "Approaches for mapping legal and AI risks", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM01:2025", "control_name": "Prompt Injection", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial"}, - {"framework": "GDPR", "control_id": "Art. 5(1)(c)", "control_name": "Data minimisation", "alignment_status": "partial"} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MAP 4.1", "control_name": "Approaches for mapping legal and AI risks", "alignment_status": "satisfied", "aibom_field": "licenses"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied", "aibom_field": "safetyRiskAssessment"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM01:2025", "control_name": "Prompt Injection", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"}, + {"framework": "GDPR", "control_id": "Art. 5(1)(c)", "control_name": "Data minimisation", "alignment_status": "partial", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "CCPA", "SOC 2"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-enterprise-search-assistant.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-enterprise-search-assistant.json index fd184a9..da1254a 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-enterprise-search-assistant.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-enterprise-search-assistant.json @@ -43,13 +43,13 @@ {"description": "Embedding inversion testing on the vector store has not been performed.", "addresses_dsgai": ["DSGAI13", "DSGAI18"], "suggested_remediation": "Run an inversion test on a representative sample of indexed sensitive content.", "urgency": "Strategic"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "partial"}, - {"framework": "NIST CSF 2.0", "control_id": "ID.AM-05", "control_name": "Resources prioritized by classification", "alignment_status": "partial"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MAP 2.3", "control_name": "Data sources documented", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "partial"}, - {"framework": "ISO/IEC 27001", "control_id": "A.5.12", "control_name": "Classification of information", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial"}, - {"framework": "SOC 2", "control_id": "CC6.3", "control_name": "Access removal upon termination", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "ID.AM-05", "control_name": "Resources prioritized by classification", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MAP 2.3", "control_name": "Data sources documented", "alignment_status": "satisfied", "aibom_field": "datasets"}, + {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "partial", "aibom_field": "datasets"}, + {"framework": "ISO/IEC 27001", "control_id": "A.5.12", "control_name": "Classification of information", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"}, + {"framework": "SOC 2", "control_id": "CC6.3", "control_name": "Access removal upon termination", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "CCPA", "SOC 2"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-financial-research-analyst.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-financial-research-analyst.json index ed9304d..336cf78 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-financial-research-analyst.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-financial-research-analyst.json @@ -40,13 +40,13 @@ {"description": "MAR (EU Market Abuse Regulation) conformity assessment pending.", "addresses_dsgai": ["DSGAI08"], "suggested_remediation": "Complete MAR-applicability analysis; document residual-risk acceptance.", "urgency": "Immediate"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.10", "control_name": "Privacy risk is evaluated", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial"}, - {"framework": "EU AI Act", "control_id": "Art. 26", "control_name": "Obligations of deployers of high-risk AI systems", "alignment_status": "partial"}, - {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.10", "control_name": "Privacy risk is evaluated", "alignment_status": "partial", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied", "aibom_field": "safetyRiskAssessment"}, + {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"}, + {"framework": "EU AI Act", "control_id": "Art. 26", "control_name": "Obligations of deployers of high-risk AI systems", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "EU AI Act", "SOC 2"], "maturity_overall": "Managed", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-hr-employee-chatbot.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-hr-employee-chatbot.json index de51891..c9845b9 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-hr-employee-chatbot.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-hr-employee-chatbot.json @@ -40,12 +40,12 @@ {"description": "No automated detection of HR-policy doc tampering.", "addresses_dsgai": ["DSGAI04", "DSGAI21"], "suggested_remediation": "Add integrity hashing on policy docs; alert on changes outside the editorial workflow.", "urgency": "Strategic"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MAP 4.1", "control_name": "Approaches for mapping legal and AI risks", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"}, - {"framework": "GDPR", "control_id": "Art. 5(1)(c)", "control_name": "Data minimisation", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MAP 4.1", "control_name": "Approaches for mapping legal and AI risks", "alignment_status": "satisfied", "aibom_field": "licenses"}, + {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "satisfied", "aibom_field": "datasets"}, + {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"}, + {"framework": "GDPR", "control_id": "Art. 5(1)(c)", "control_name": "Data minimisation", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "CCPA", "SOC 2"], "maturity_overall": "Managed", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-insurance-claims-triage.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-insurance-claims-triage.json index d4dc7e9..7b6cfe3 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-insurance-claims-triage.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-insurance-claims-triage.json @@ -40,13 +40,13 @@ {"description": "Image tamper-detection is heuristic; no signed-camera-attestation accepted.", "addresses_dsgai": ["DSGAI04", "DSGAI21"], "suggested_remediation": "Pilot signed-camera attestation acceptance for high-severity claims.", "urgency": "Strategic"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.11", "control_name": "Fairness and bias evaluated", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied"}, - {"framework": "EU AI Act", "control_id": "Annex III(5)", "control_name": "High-risk: insurance and creditworthiness", "alignment_status": "partial"}, - {"framework": "GDPR", "control_id": "Art. 22", "control_name": "Automated individual decision-making", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"}, - {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.11", "control_name": "Fairness and bias evaluated", "alignment_status": "satisfied", "aibom_field": "ethicalConsiderations"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied", "aibom_field": "safetyRiskAssessment"}, + {"framework": "EU AI Act", "control_id": "Annex III(5)", "control_name": "High-risk: insurance and creditworthiness", "alignment_status": "partial", "aibom_field": "intendedUse"}, + {"framework": "GDPR", "control_id": "Art. 22", "control_name": "Automated individual decision-making", "alignment_status": "satisfied", "aibom_field": "autonomyType"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"}, + {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "CCPA", "EU AI Act", "SOC 2"], "maturity_overall": "Managed", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-internal-code-assistant.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-internal-code-assistant.json index e95a524..af577b4 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-internal-code-assistant.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-internal-code-assistant.json @@ -46,14 +46,14 @@ {"description": "Historical secrets in monorepo test fixtures remain indexed.", "addresses_dsgai": ["DSGAI01", "DSGAI04"], "suggested_remediation": "Run a one-time secret sweep of the index; rotate any still-active secrets; exclude fixture paths from indexing.", "urgency": "Immediate"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "partial"}, - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions managed with least privilege", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MAP 4.1", "control_name": "Approaches for mapping AI technology and legal risks", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.1.2", "control_name": "AI policy", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 27001", "control_id": "A.8.10", "control_name": "Information deletion", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM03:2025", "control_name": "Supply Chain", "alignment_status": "partial"}, - {"framework": "SOC 2", "control_id": "CC6.7", "control_name": "Restriction of access to information assets", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions managed with least privilege", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MAP 4.1", "control_name": "Approaches for mapping AI technology and legal risks", "alignment_status": "partial", "aibom_field": "licenses"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.1.2", "control_name": "AI policy", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "ISO/IEC 27001", "control_id": "A.8.10", "control_name": "Information deletion", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM03:2025", "control_name": "Supply Chain", "alignment_status": "partial", "aibom_field": "suppliedBy"}, + {"framework": "SOC 2", "control_id": "CC6.7", "control_name": "Restriction of access to information assets", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["SOC 2", "GDPR"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-marketing-content-generator.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-marketing-content-generator.json index 3a0f32e..61f5f16 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-marketing-content-generator.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-marketing-content-generator.json @@ -40,12 +40,12 @@ {"description": "AI-disclosure labeling is end-of-process; in-draft signaling absent for reviewers.", "addresses_dsgai": ["DSGAI08"], "suggested_remediation": "Mark AI-generated sections inside the editorial UI so reviewers can apply heightened scrutiny.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.IP-12", "control_name": "Vulnerability management plan", "alignment_status": "partial"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.11", "control_name": "Fairness and bias evaluated", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.7.3", "control_name": "AI system design and development", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM01:2025", "control_name": "Prompt Injection", "alignment_status": "partial"}, - {"framework": "EU AI Act", "control_id": "Art. 50", "control_name": "Transparency for content-generation systems", "alignment_status": "satisfied"}, - {"framework": "GDPR", "control_id": "Art. 5(1)(d)", "control_name": "Accuracy", "alignment_status": "partial"} + {"framework": "NIST CSF 2.0", "control_id": "PR.IP-12", "control_name": "Vulnerability management plan", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.11", "control_name": "Fairness and bias evaluated", "alignment_status": "partial", "aibom_field": "ethicalConsiderations"}, + {"framework": "ISO/IEC 42001", "control_id": "A.7.3", "control_name": "AI system design and development", "alignment_status": "satisfied", "aibom_field": "informationAboutTraining"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM01:2025", "control_name": "Prompt Injection", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"}, + {"framework": "EU AI Act", "control_id": "Art. 50", "control_name": "Transparency for content-generation systems", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"}, + {"framework": "GDPR", "control_id": "Art. 5(1)(d)", "control_name": "Accuracy", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"} ], "compliance_obligations": ["GDPR", "EU AI Act"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-multi-agent-customer-support.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-multi-agent-customer-support.json index ec3c3b5..a8f1eec 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-multi-agent-customer-support.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-multi-agent-customer-support.json @@ -47,14 +47,14 @@ {"description": "Inter-agent message volume / cost not capped per customer.", "addresses_dsgai": ["DSGAI17"], "suggested_remediation": "Per-customer agent-chain budget caps; alert on cost-harvesting patterns.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied"}, - {"framework": "NIST CSF 2.0", "control_id": "DE.AE-02", "control_name": "Detected events analyzed", "alignment_status": "partial"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MANAGE 3.2", "control_name": "AI risks are responded to", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.7.3", "control_name": "AI system design and development", "alignment_status": "satisfied"}, - {"framework": "OWASP Agentic Top 10 2026", "control_id": "AGT-01", "control_name": "Tool privilege management", "alignment_status": "partial", "notes": "Per-agent scoping in place; cross-agent privilege escalation paths not fully audited."}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM05:2025", "control_name": "Improper Output Handling", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM07:2025", "control_name": "System Prompt Leakage", "alignment_status": "partial"}, - {"framework": "SOC 2", "control_id": "CC7.2", "control_name": "Monitoring activities", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "DE.AE-02", "control_name": "Detected events analyzed", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MANAGE 3.2", "control_name": "AI risks are responded to", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "ISO/IEC 42001", "control_id": "A.7.3", "control_name": "AI system design and development", "alignment_status": "satisfied", "aibom_field": "informationAboutTraining"}, + {"framework": "OWASP Agentic Top 10 2026", "control_id": "AGT-01", "control_name": "Tool privilege management", "alignment_status": "partial", "notes": "Per-agent scoping in place; cross-agent privilege escalation paths not fully audited.", "aibom_field_none": "deployment-control"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM05:2025", "control_name": "Improper Output Handling", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM07:2025", "control_name": "System Prompt Leakage", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"}, + {"framework": "SOC 2", "control_id": "CC7.2", "control_name": "Monitoring activities", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "SOC 2"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-multi-tenant-saas-ai-feature.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-multi-tenant-saas-ai-feature.json index 0591f31..a4d2ba0 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-multi-tenant-saas-ai-feature.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-multi-tenant-saas-ai-feature.json @@ -43,13 +43,13 @@ {"description": "Legacy tenants on per-tenant DB and newer tenants on shared DB have inconsistent isolation guarantees.", "addresses_dsgai": ["DSGAI11", "DSGAI13"], "suggested_remediation": "Document the isolation model per tenant; communicate the gap to enterprise customers.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-05", "control_name": "Network integrity is protected", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MAP 1.1", "control_name": "Context for AI system established", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.7.4", "control_name": "Verification and validation", "alignment_status": "partial"}, - {"framework": "ISO/IEC 27001", "control_id": "A.5.10", "control_name": "Acceptable use", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM08:2025", "control_name": "Vector and Embedding Weaknesses", "alignment_status": "partial"}, - {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-05", "control_name": "Network integrity is protected", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MAP 1.1", "control_name": "Context for AI system established", "alignment_status": "satisfied", "aibom_field": "intendedUse"}, + {"framework": "ISO/IEC 42001", "control_id": "A.7.4", "control_name": "Verification and validation", "alignment_status": "partial", "aibom_field": "metric"}, + {"framework": "ISO/IEC 27001", "control_id": "A.5.10", "control_name": "Acceptable use", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM08:2025", "control_name": "Vector and Embedding Weaknesses", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "CCPA", "HIPAA", "SOC 2", "ISO 27001 certification"], "maturity_overall": "Managed", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-public-sector-citizen-chatbot.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-public-sector-citizen-chatbot.json index 6816682..c543e45 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-public-sector-citizen-chatbot.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-public-sector-citizen-chatbot.json @@ -43,13 +43,13 @@ {"description": "Public-records retention schedule does not yet specify PII-redacted vs raw transcript handling.", "addresses_dsgai": ["DSGAI14", "DSGAI08"], "suggested_remediation": "Update retention schedule to differentiate PII-redacted from raw and align with the agency's records-management authority.", "urgency": "Immediate"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-02", "control_name": "Data-in-transit is protected", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "GOVERN 1.5", "control_name": "Ongoing monitoring and review", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "partial"}, - {"framework": "ISO/IEC 27001", "control_id": "A.5.31", "control_name": "Legal, statutory, regulatory, and contractual requirements", "alignment_status": "satisfied"}, - {"framework": "EU AI Act", "control_id": "Art. 49", "control_name": "Registration in EU database for high-risk systems", "alignment_status": "partial"}, - {"framework": "GDPR", "control_id": "Art. 35", "control_name": "Data protection impact assessment", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-02", "control_name": "Data-in-transit is protected", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "GOVERN 1.5", "control_name": "Ongoing monitoring and review", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "partial", "aibom_field": "safetyRiskAssessment"}, + {"framework": "ISO/IEC 27001", "control_id": "A.5.31", "control_name": "Legal, statutory, regulatory, and contractual requirements", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "EU AI Act", "control_id": "Art. 49", "control_name": "Registration in EU database for high-risk systems", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "GDPR", "control_id": "Art. 35", "control_name": "Data protection impact assessment", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"} ], "compliance_obligations": ["GDPR", "EU AI Act", "UK Data Protection Act 2018"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-resume-screening-ai.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-resume-screening-ai.json index c3648d7..9a3cd62 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-resume-screening-ai.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-resume-screening-ai.json @@ -43,13 +43,13 @@ {"description": "DSAR / right-to-explanation workflow not fully automated.", "addresses_dsgai": ["DSGAI08"], "suggested_remediation": "Build a per-candidate decision-explanation export that includes the ranking inputs and the audit-trail reference.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.11", "control_name": "Fairness and bias evaluated", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied"}, - {"framework": "EU AI Act", "control_id": "Annex III(4)", "control_name": "High-risk: employment", "alignment_status": "partial"}, - {"framework": "GDPR", "control_id": "Art. 22", "control_name": "Automated individual decision-making", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.11", "control_name": "Fairness and bias evaluated", "alignment_status": "partial", "aibom_field": "ethicalConsiderations"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied", "aibom_field": "safetyRiskAssessment"}, + {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "EU AI Act", "control_id": "Annex III(4)", "control_name": "High-risk: employment", "alignment_status": "partial", "aibom_field": "intendedUse"}, + {"framework": "GDPR", "control_id": "Art. 22", "control_name": "Automated individual decision-making", "alignment_status": "partial", "aibom_field": "autonomyType"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"} ], "compliance_obligations": ["GDPR", "CCPA", "EU AI Act", "SOC 2"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-self-hosted-open-weights.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-self-hosted-open-weights.json index 260f5ae..6e4c5b7 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-self-hosted-open-weights.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-self-hosted-open-weights.json @@ -42,13 +42,13 @@ {"description": "Cross-region failover is planned but not implemented.", "addresses_dsgai": ["DSGAI17"], "suggested_remediation": "Stand up a warm-standby cluster; exercise failover quarterly.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-06", "control_name": "Integrity checking mechanisms verify integrity", "alignment_status": "satisfied"}, - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.7", "control_name": "AI system security is evaluated", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.8", "control_name": "Data quality for AI systems", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 27001", "control_id": "A.5.7", "control_name": "Threat intelligence", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM03:2025", "control_name": "Supply Chain", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM10:2025", "control_name": "Unbounded Consumption", "alignment_status": "partial"} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-06", "control_name": "Integrity checking mechanisms verify integrity", "alignment_status": "satisfied", "aibom_field_none": "no-registry-field"}, + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-04", "control_name": "Access permissions with least privilege", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.7", "control_name": "AI system security is evaluated", "alignment_status": "partial", "aibom_field_none": "no-registry-field"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.8", "control_name": "Data quality for AI systems", "alignment_status": "satisfied", "aibom_field": "modelDataPreprocessing"}, + {"framework": "ISO/IEC 27001", "control_id": "A.5.7", "control_name": "Threat intelligence", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM03:2025", "control_name": "Supply Chain", "alignment_status": "satisfied", "aibom_field": "suppliedBy"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM10:2025", "control_name": "Unbounded Consumption", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"} ], "compliance_obligations": ["SOC 2", "ISO 27001 certification"], "maturity_overall": "Defined", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-soc-analyst-copilot.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-soc-analyst-copilot.json index d0450e4..9d8c9e8 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-soc-analyst-copilot.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-soc-analyst-copilot.json @@ -42,14 +42,14 @@ {"description": "High-blast destructive actions (mass-isolation, broad block) not explicitly excluded.", "addresses_dsgai": ["DSGAI02", "DSGAI17"], "suggested_remediation": "Enumerate destructive actions and require break-glass approval flow; default-deny in copilot tool set.", "urgency": "Immediate"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "DE.AE-02", "control_name": "Detected events analyzed", "alignment_status": "satisfied"}, - {"framework": "NIST CSF 2.0", "control_id": "RS.AN-01", "control_name": "Investigations are conducted", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.7", "control_name": "AI system security is evaluated", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.7.3", "control_name": "AI system design and development", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM06:2025", "control_name": "Excessive Agency", "alignment_status": "satisfied"}, - {"framework": "OWASP Agentic Top 10 2026", "control_id": "AGT-02", "control_name": "Blast-radius limiting", "alignment_status": "partial"}, - {"framework": "MITRE ATT&CK", "control_id": "M1056", "control_name": "Pre-compromise hardening", "alignment_status": "satisfied"}, - {"framework": "SOC 2", "control_id": "CC7.3", "control_name": "Security incidents are identified", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "DE.AE-02", "control_name": "Detected events analyzed", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "RS.AN-01", "control_name": "Investigations are conducted", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.7", "control_name": "AI system security is evaluated", "alignment_status": "satisfied", "aibom_field_none": "no-registry-field"}, + {"framework": "ISO/IEC 42001", "control_id": "A.7.3", "control_name": "AI system design and development", "alignment_status": "satisfied", "aibom_field": "informationAboutTraining"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM06:2025", "control_name": "Excessive Agency", "alignment_status": "satisfied", "aibom_field": "autonomyType"}, + {"framework": "OWASP Agentic Top 10 2026", "control_id": "AGT-02", "control_name": "Blast-radius limiting", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "MITRE ATT&CK", "control_id": "M1056", "control_name": "Pre-compromise hardening", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "SOC 2", "control_id": "CC7.3", "control_name": "Security incidents are identified", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["SOC 2", "ISO 27001 certification"], "maturity_overall": "Managed", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-synthetic-data-pipeline.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-synthetic-data-pipeline.json index e44e23f..db50c3b 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-synthetic-data-pipeline.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-synthetic-data-pipeline.json @@ -40,12 +40,12 @@ {"description": "Generator-model retraining on synthetic outputs is policy-prohibited but not technically enforced.", "addresses_dsgai": ["DSGAI04", "DSGAI05"], "suggested_remediation": "Tag every synthesized record so downstream training pipelines can detect and refuse synthetic-on-synthetic loops.", "urgency": "Strategic"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-04", "control_name": "Adequate capacity to ensure availability", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.10", "control_name": "Privacy risk is evaluated", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 27001", "control_id": "A.8.11", "control_name": "Data masking", "alignment_status": "satisfied"}, - {"framework": "GDPR", "control_id": "Art. 25", "control_name": "Data protection by design and default", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-04", "control_name": "Adequate capacity to ensure availability", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.10", "control_name": "Privacy risk is evaluated", "alignment_status": "satisfied", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "satisfied", "aibom_field": "datasets"}, + {"framework": "ISO/IEC 27001", "control_id": "A.8.11", "control_name": "Data masking", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "GDPR", "control_id": "Art. 25", "control_name": "Data protection by design and default", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"} ], "compliance_obligations": ["GDPR", "CCPA", "ISO 27001 certification"], "maturity_overall": "Defined", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-translation-localization-assistant.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-translation-localization-assistant.json index 06b9f6b..7c54956 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-translation-localization-assistant.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-translation-localization-assistant.json @@ -37,11 +37,11 @@ {"description": "Audit-log retention does not differentiate translated PII from raw.", "addresses_dsgai": ["DSGAI14", "DSGAI08"], "suggested_remediation": "Apply field-level redaction to translated outputs; separate retention bucket for sensitive translations.", "urgency": "Strategic"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MAP 4.1", "control_name": "Approaches for mapping legal and AI risks", "alignment_status": "satisfied"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.1.2", "control_name": "AI policy", "alignment_status": "satisfied"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"}, - {"framework": "GDPR", "control_id": "Art. 28", "control_name": "Processor obligations", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MAP 4.1", "control_name": "Approaches for mapping legal and AI risks", "alignment_status": "satisfied", "aibom_field": "licenses"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.1.2", "control_name": "AI policy", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"}, + {"framework": "GDPR", "control_id": "Art. 28", "control_name": "Processor obligations", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "SOC 2"], "maturity_overall": "Defined", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-tutoring-assistant-k12.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-tutoring-assistant-k12.json index 2ecb364..6851a65 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-tutoring-assistant-k12.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-tutoring-assistant-k12.json @@ -40,12 +40,12 @@ {"description": "No formal periodic notice to parents about AI use in instruction.", "addresses_dsgai": ["DSGAI08"], "suggested_remediation": "Annual AI-use notice integrated with district communication cycles.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "GOVERN 1.5", "control_name": "Ongoing monitoring and review", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied"}, - {"framework": "FERPA", "control_id": "34 CFR 99.31", "control_name": "Disclosure without consent permitted", "alignment_status": "satisfied"}, - {"framework": "EU AI Act", "control_id": "Annex III(3)", "control_name": "High-risk: education and vocational training", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied"} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-05", "control_name": "Protections against data leaks", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "GOVERN 1.5", "control_name": "Ongoing monitoring and review", "alignment_status": "partial", "aibom_field_none": "deployment-control"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied", "aibom_field": "safetyRiskAssessment"}, + {"framework": "FERPA", "control_id": "34 CFR 99.31", "control_name": "Disclosure without consent permitted", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "EU AI Act", "control_id": "Annex III(3)", "control_name": "High-risk: education and vocational training", "alignment_status": "partial", "aibom_field": "intendedUse"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "aibom_field_none": "runtime-behaviour"} ], "compliance_obligations": ["FERPA", "GDPR", "EU AI Act"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/entries/DSGAI-RA-voice-in-vehicle-assistant.json b/datasets/riskassessment_dataset/entries/DSGAI-RA-voice-in-vehicle-assistant.json index d75dd6d..d4b29f6 100644 --- a/datasets/riskassessment_dataset/entries/DSGAI-RA-voice-in-vehicle-assistant.json +++ b/datasets/riskassessment_dataset/entries/DSGAI-RA-voice-in-vehicle-assistant.json @@ -39,12 +39,12 @@ {"description": "Rental-mode is operator-opt-in; many shared vehicles do not enable it.", "addresses_dsgai": ["DSGAI11"], "suggested_remediation": "Detect rental fleet via VIN-list; enable rental-mode by default; require operator opt-out.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-07", "control_name": "Users authenticated for access", "alignment_status": "satisfied"}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.10", "control_name": "Privacy risk is evaluated", "alignment_status": "partial"}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied"}, - {"framework": "GDPR", "control_id": "Art. 9", "control_name": "Processing of special categories (biometrics)", "alignment_status": "partial"}, - {"framework": "EU AI Act", "control_id": "Art. 5", "control_name": "Prohibited AI practices (biometric categorisation)", "alignment_status": "partial"}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial"} + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-07", "control_name": "Users authenticated for access", "alignment_status": "satisfied", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.10", "control_name": "Privacy risk is evaluated", "alignment_status": "partial", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied", "aibom_field": "safetyRiskAssessment"}, + {"framework": "GDPR", "control_id": "Art. 9", "control_name": "Processing of special categories (biometrics)", "alignment_status": "partial", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "EU AI Act", "control_id": "Art. 5", "control_name": "Prohibited AI practices (biometric categorisation)", "alignment_status": "partial", "aibom_field": "intendedUse"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "partial", "aibom_field_none": "runtime-behaviour"} ], "compliance_obligations": ["GDPR", "CCPA", "EU AI Act"], "maturity_overall": "Developing", diff --git a/datasets/riskassessment_dataset/example.json b/datasets/riskassessment_dataset/example.json index 810ee52..77f3b5a 100644 --- a/datasets/riskassessment_dataset/example.json +++ b/datasets/riskassessment_dataset/example.json @@ -52,19 +52,19 @@ {"description": "Adversarial-input red-team exercise not yet a release gate.", "addresses_dsgai": ["DSGAI21", "DSGAI06"], "suggested_remediation": "Add a published red-team corpus to the release gate; track refusal stability across versions.", "urgency": "Near-term"} ], "framework_alignments": [ - {"framework": "NIST CSF 2.0", "control_id": "PR.DS-01", "control_name": "Data-at-rest is protected", "alignment_status": "satisfied", "notes": "KMS-managed encryption across KB, vector store, logs."}, - {"framework": "NIST CSF 2.0", "control_id": "PR.AC-01", "control_name": "Identities and credentials are managed", "alignment_status": "satisfied", "notes": "Short-lived IDP tokens; no static service credentials."}, - {"framework": "NIST CSF 2.0", "control_id": "DE.CM-01", "control_name": "The network is monitored", "alignment_status": "partial", "notes": "Prompt/response monitoring exists; injection-rate anomaly detection not yet."}, - {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.7", "control_name": "AI system security is evaluated and documented", "alignment_status": "partial", "notes": "Red-team exercises run; not yet a release gate."}, - {"framework": "NIST AI RMF 1.0", "control_id": "GOVERN 5.1", "control_name": "Policies and procedures are in place for AI risk management", "alignment_status": "satisfied", "notes": "DPIA + AI risk policy maintained by the bank's model risk function."}, - {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied", "notes": "DPIA + DSGAI-aligned assessment cycle annual."}, - {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "satisfied", "notes": "KB and embedding store have classification labels and provenance."}, - {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied", "notes": "DSAR pipeline; field-level redaction."}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM01:2025", "control_name": "Prompt Injection", "alignment_status": "partial", "notes": "Detection in place; adversarial release-gate testing planned."}, - {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "notes": "PII regex on input and output; logs redacted."}, - {"framework": "GDPR", "control_id": "Art. 35", "control_name": "Data protection impact assessment", "alignment_status": "satisfied", "notes": "DPIA on file with the bank's DPO."}, - {"framework": "EU AI Act", "control_id": "Art. 26", "control_name": "Obligations of deployers of high-risk AI systems", "alignment_status": "partial", "notes": "Classification pending; documentation in progress."}, - {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied", "notes": "Inherited from underlying SOC 2 Type II program."} + {"framework": "NIST CSF 2.0", "control_id": "PR.DS-01", "control_name": "Data-at-rest is protected", "alignment_status": "satisfied", "notes": "KMS-managed encryption across KB, vector store, logs.", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "PR.AC-01", "control_name": "Identities and credentials are managed", "alignment_status": "satisfied", "notes": "Short-lived IDP tokens; no static service credentials.", "aibom_field_none": "deployment-control"}, + {"framework": "NIST CSF 2.0", "control_id": "DE.CM-01", "control_name": "The network is monitored", "alignment_status": "partial", "notes": "Prompt/response monitoring exists; injection-rate anomaly detection not yet.", "aibom_field_none": "deployment-control"}, + {"framework": "NIST AI RMF 1.0", "control_id": "MEASURE 2.7", "control_name": "AI system security is evaluated and documented", "alignment_status": "partial", "notes": "Red-team exercises run; not yet a release gate.", "aibom_field_none": "no-registry-field"}, + {"framework": "NIST AI RMF 1.0", "control_id": "GOVERN 5.1", "control_name": "Policies and procedures are in place for AI risk management", "alignment_status": "satisfied", "notes": "DPIA + AI risk policy maintained by the bank's model risk function.", "aibom_field_none": "deployment-control"}, + {"framework": "ISO/IEC 42001", "control_id": "A.6.2.6", "control_name": "AI system impact assessment", "alignment_status": "satisfied", "notes": "DPIA + DSGAI-aligned assessment cycle annual.", "aibom_field": "safetyRiskAssessment"}, + {"framework": "ISO/IEC 42001", "control_id": "A.8.2", "control_name": "Data resources for AI systems", "alignment_status": "satisfied", "notes": "KB and embedding store have classification labels and provenance.", "aibom_field": "datasets"}, + {"framework": "ISO/IEC 27001", "control_id": "A.5.34", "control_name": "Privacy and protection of PII", "alignment_status": "satisfied", "notes": "DSAR pipeline; field-level redaction.", "aibom_field": "useSensitivePersonalInformation"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM01:2025", "control_name": "Prompt Injection", "alignment_status": "partial", "notes": "Detection in place; adversarial release-gate testing planned.", "aibom_field_none": "runtime-behaviour"}, + {"framework": "OWASP LLM Top 10 2025", "control_id": "LLM02:2025", "control_name": "Sensitive Information Disclosure", "alignment_status": "satisfied", "notes": "PII regex on input and output; logs redacted.", "aibom_field_none": "runtime-behaviour"}, + {"framework": "GDPR", "control_id": "Art. 35", "control_name": "Data protection impact assessment", "alignment_status": "satisfied", "notes": "DPIA on file with the bank's DPO.", "aibom_field_none": "deployment-control"}, + {"framework": "EU AI Act", "control_id": "Art. 26", "control_name": "Obligations of deployers of high-risk AI systems", "alignment_status": "partial", "notes": "Classification pending; documentation in progress.", "aibom_field_none": "deployment-control"}, + {"framework": "SOC 2", "control_id": "CC6.1", "control_name": "Logical and physical access controls", "alignment_status": "satisfied", "notes": "Inherited from underlying SOC 2 Type II program.", "aibom_field_none": "deployment-control"} ], "compliance_obligations": ["GDPR", "CCPA", "SOC 2", "ISO 27001 certification", "EU AI Act", "DORA"], "maturity_overall": "Managed", diff --git a/datasets/riskassessment_dataset/schema.json b/datasets/riskassessment_dataset/schema.json index d7d0546..1553af4 100644 --- a/datasets/riskassessment_dataset/schema.json +++ b/datasets/riskassessment_dataset/schema.json @@ -230,6 +230,7 @@ "CIS Controls v8", "OWASP LLM Top 10 2025", "OWASP Agentic Top 10 2026", + "OWASP MCP Top 10", "MITRE ATLAS", "MITRE ATT&CK", "EU AI Act", @@ -248,7 +249,28 @@ "type": "string", "enum": ["satisfied", "partial", "missing", "not_applicable"] }, - "notes": { "type": "string" } + "notes": { "type": "string" }, + "aibom_field": { + "description": "The field of a generated CycloneDX AIBOM that evidences this control: an id from the OWASP AIBOM Generator's src/models/field_registry.json (for example datasets, metric or safetyRiskAssessment). data_validation/validators/aibom_field_check.py checks it against data_validation/reference_data/aibom_fields.csv.", + "type": "string", + "pattern": "^[A-Za-z][A-Za-z0-9_]*$" + }, + "aibom_field_none": { + "description": "Why no field of a generated AIBOM evidences this control, for a row without aibom_field. deployment-control: the deploying organisation meets the control with its own systems, processes or legal obligations (access, encryption, monitoring, incident response, contracts, policies), which an AIBOM of the model does not record. runtime-behaviour: the control is about what the running application does with live inputs and outputs (prompt injection, disclosure filtering, output handling, rate limits), which a static AIBOM does not record. no-registry-field: the control is about the model itself, but field_registry.json has no field that records it.", + "type": "string", + "enum": ["deployment-control", "runtime-behaviour", "no-registry-field"] + }, + "test_records": { + "description": "Published signed test records this row rests on: a corpus shipped in the pinned agent-evidence-vectors package and, optionally, one requirement in its REGISTRY.json. data_validation/validators/evidence_mapping_check.py replays the corpus with its reference verifier.", + "type": "object", + "additionalProperties": false, + "required": ["package", "corpus"], + "properties": { + "package": { "const": "agent-evidence-vectors" }, + "corpus": { "type": "string", "pattern": "^vectors(-[a-z0-9]+)*$" }, + "requirement": { "type": "string", "minLength": 1 } + } + } } }, "minItems": 4