skip to content

What belongs in a machine-readable crosswalk mapping one check to clauses in several frameworks?

level: middleimportance: should knowfreq 47%

answer

  1. a table of edges, not a rule
  2. one block per framework
  3. pin the catalog revision you mapped against
  4. every edge names its check
  5. reviewed as a pull request, diffable

basics

~10 s

Per framework: the catalog revision being mapped against, the clause identifier, the check that answers it, how strongly it answers it, and an owner. OSCAL expresses this as one control-implementation block per framework.

solid answer

~50 s

The unit is an edge, and every edge needs five things: which component or service it describes, which framework catalog it targets **and at which revision**, the clause identifier inside that catalog, the identifier of the check that produces the result, and the strength of the claim. In OSCAL you get this from a component definition: a component carries one `control-implementations` block per framework, each with a `source` naming that framework's catalog or profile, and inside it one `implemented-requirement` per clause carrying a `control-id` and a description or prop naming the check. Keep the file in the policy repository beside the rules, so a mapping change arrives as a reviewable diff with an author, not a spreadsheet edit nobody can date. And be clear about what the file is not: it never blocks anything. It decides which report a failing check lands in.

code

yaml · 21 lines
yaml
component-definition:
  components:
    - title: Edge TLS termination
      type: service
      control-implementations:
        - source: catalogs/nist-sp-800-53-rev5.json   # revision pinned here
          implemented-requirements:
            - control-id: sc-8
              description: >-
                Answered by check tls-min-version: every externally reachable
                listener negotiates TLS 1.2 or higher.
              props:
                - name: check-id
                  value: tls-min-version
                - name: edge-strength
                  value: full
        - source: catalogs/pci-dss-v4.json            # in-house catalog
          implemented-requirements:
            - control-id: req-4
              description: Same check, scoped to listeners in the CDE.
              ...

go deeper

for a junior

Know that the mapping is a file in the repository next to the rules, not a spreadsheet, and that each row ties one check to one clause of one framework.

for a middle

Be able to name the fields an edge must carry — subject, framework and revision, clause id, check id, strength, owner — and describe how OSCAL's component definition arranges them one block per framework.

for a senior

Demonstrate the review discipline: resolving ids against the pinned catalog, catching mappings to renamed or disabled checks, and treating a deleted edge as seriously as a deleted test.

for a principal

Argue for the mapping as a maintained asset with an owner and a change process, and be ready to say who pays for that maintenance when a new framework arrives mid-quarter.

## Why the crosswalk is a file and not a spreadsheet The mapping between checks and framework clauses is a claim you will be asked to defend, sometimes a year after you made it. That makes three properties non-negotiable: it must be **diffable** (what changed and when), **attributable** (who decided), and **resolvable** (does the identifier it names still exist). A spreadsheet gives you none of the three. A structured file in the policy repository gives you all three for free, using the review machinery the rules already use. ## The anatomy of one edge Regardless of format, an edge carries: 1. **Subject** — what is being described. A service, a platform component, a control implementation. Not "the company". 2. **Framework and revision** — not "NIST 800-53" but the specific catalog document you mapped against. Revisions move identifiers; an unpinned mapping cannot be checked later. 3. **Clause identifier** — the id as the catalog spells it. 4. **The check** — the identifier of the rule whose results answer the clause. Without it, the edge is an opinion; with it, a failing result can be routed. 5. **Strength** — whether the check fully answers the clause or only part of it, from a closed vocabulary rather than free text. 6. **Owner** — a human who decided, and who is asked when it is disputed. ## How OSCAL expresses it OSCAL, the Open Security Controls Assessment Language, splits the problem into layers. The controls layer holds **catalogs** (a framework's controls as structured data) and **profiles** (a tailored selection of them — a baseline). The implementation layer holds **component definitions** and **system security plans**, which say how something implements controls. The assessment layer holds plans and results. A crosswalk of the kind this question asks about lives most naturally as a **component definition**. Its shape: - A `component` — your service, with a title and type. - One or more `control-implementations`, **one per framework**. Each has a `source`: a URI pointing at the catalog or profile whose identifiers the block uses. This is where the revision is pinned. - Inside each, `implemented-requirements`, one per clause, each with a `control-id` and a description. `props` and `links` let you attach machine-readable extras — the check identifier, a link to the rule, the edge's strength. So the same component appears once, and the framework-specific vocabulary is confined to its own block. Adding a fourth framework adds a fourth `control-implementations` entry; it does not touch the other three, which is exactly the property you want in review. ## The review that actually matters A crosswalk pull request is not a rubber stamp. A reviewer checks: - **Does the clause identifier resolve** in the pinned catalog? An id that no longer exists is the commonest defect after a framework revision. - **Does the named check exist and is it the one that runs?** A mapping to a rule that was renamed or disabled is worse than no mapping, because the report shows a heading with nothing behind it. - **Is the strength honest?** Full versus partial is a claim about what an auditor will find. Silence defaults to full in most renderers, which is how optimistic mappings get made by accident. - **Is a removal deliberate?** Deleting an edge makes a report look better. That should be as hard to land as deleting a test. ## What it is not The crosswalk is not enforcement. No engine reads it to decide whether to admit a resource or fail a build; the check does that, if it does it at all. Mapping a check to three clauses does not make it stricter, and unmapping it does not make a broken listener safe. It is also not the evidence. The edge says a clause is answered by a check; the record that the check ran, what it saw and what happened next lives elsewhere and is the thing an auditor actually samples. Confusing the map with the territory — presenting the crosswalk itself as proof the control operated — is the mistake that turns a good artifact into a liability.

  • Why pin a catalog revision instead of just naming the framework?
    Because identifiers move between revisions. With the revision pinned you can mechanically resolve every clause id in the crosswalk against that exact catalog and see which edges no longer land, and you can date the decision — this mapping was made against that text. An unpinned mapping cannot be verified or aged; it can only be argued about.
  • What should a reviewer actually check on a crosswalk change?
    That the clause id resolves in the pinned catalog; that the named check exists and is the one currently running; that the edge's strength is stated rather than left to default to full; and that any removed edge was removed on purpose. Deleting an edge quietly improves a report, so it deserves the same scrutiny as deleting a test.

saying these in an interview costs you the question

  • Keeps the crosswalk in a spreadsheet outside version control
  • Names a framework without pinning its revision
  • Maps to a clause without naming the check that answers it
  • Expects the crosswalk file to block or gate anything
  • Presents the mapping itself as evidence the control operated

context