Checks · kernel 2.0.0, release candidate

When the assessor is a machine

A scanner that exits with 0 or 1 hides its threshold, ignores the tailoring and leaves nothing to re-examine. A Check publishes the facts a collector must report and the comparisons that decide. The run record carries what was observed, so anyone recomputes the verdict from the record.

eleventh kernel type, 2.0.0 candidate 205 vectors pass in three implementations 2.0.0 is not tagged

01 The gap

The automation exists at the publisher and is lost on the way

JASCON 1.0.0 can say that a requirement was assessed and what the assessor concluded. It cannot say how a machine decides.

291 of 312

rules of the CIS Ubuntu 24.04 Benchmark are marked automated

Every one of them arrives in a converted bundle as an audit string with shell excerpts in prose. The pass condition is a sentence such as "verify the output is", which a person has to read.

0 of 3

census authorities encode a machine-decidable check

The ISM, Grundschutz++ and SP 800-53 name methods (examine, interview, test) and required documentation. FedRAMP CR26 carries key tests as prose. None of them specifies a check a program can evaluate.

Counts: CP-CHECK-1, section 2.1, from the coverage reports of the converted corpora.

02 The design

The collector observes, the criteria decide

The line is drawn where tools must agree. Two conformant tools given the same Check and the same observation return the same verdict. Everything that may differ between honest tools without changing the verdict stays outside the kernel.

Facet, outside the kernel

Collector

A shell script, an Ansible task or an API call, carried on the Check so that the check's digest covers the exact code. It prints one observation and decides nothing.

Kernel: the fact contract

Observation

Named, typed facts such as sshd.maxauthtries: integer. A collector reports effective values, with defaults resolved. An absent key means "looked and did not find".

Kernel: twelve comparators

Criteria

A flat conjunction such as at-most {param}. The expected value is a literal or a parameter of the requirement, so the Tailoring that binds the parameter sets the pass mark.

Kernel: check-verdict

Verdict

Satisfied, not satisfied, inconclusive or not applicable: a pure function of the Check, the observation and the bound parameters. The validator recomputes every recorded verdict.

A tailored parameter retunes the check

Tighten max-auth-tries from 6 to 4 in the Tailoring, and yesterday's observation of 5 turns from satisfied to not satisfied. No line of code changes, and an implementer cannot set its own pass mark.

A verdict is recomputed, never trusted

The Assessment row holds the observation itself. A second party evaluates the criteria on it and compares. A recorded outcome that differs from the computed one is a validation error.

The record shows what was observed

A failing row reads sshd.ciphers matches-not ".*-cbc", observed a list that contains aes128-cbc. An exit code would have said 1.

03 Try it

Set the observation, move the pass mark

The worked example of the repository: one requirement with two clauses, a Tailoring for production hosts, two Checks and two recorded daily runs of a bastion host. Change what the collector saw or what the Tailoring binds.

LNX-SSH-1 on bastion-01 worked example of the repository
The requirement

s1 The SSH daemon allows at most 4 authentication attempts per connection.

s2 The SSH daemon offers no cipher in CBC mode.

The collector observedsshd.ciphers
Recorded runs
Result of the assessment …

Computed in your browser by the app's port of check-verdict, the code that passes the 205 check vectors. No collector runs here; the observation is the one you set.

{
  "id": "https://cso.example/check/LNX-SSH-1-maxauthtries",
  "requirement-ref": "https://cso.example/req/LNX-SSH-1",
  "statement-ids": ["s1"],
  "platform": "https://cso.example/platform/linux-host",
  "observes": [
    { "name": "sshd.maxauthtries", "type": "integer" }
  ],
  "criteria": [
    { "fact": "sshd.maxauthtries", "op": "at-most",
      "expected": { "param": "max-auth-tries" } }
  ],
  "validity": { "num": 24, "unit": "hours" },
  "confidence": "reviewed",
  "facets": {
    "https://ns.jascon.net/stdlib/facet/collector@1": {
      "collectors": [
        { "id": "bash", "runtime": "bash", "privileges": "root",
          "source": "#!/bin/bash\nv=$(sshd -T | awk '$1==\"maxauthtries\"{print $2}') ..." }
      ]
    }
  }
}
{
  "check-ref": "https://cso.example/check/LNX-SSH-1-ciphers",
  "check-digest": "sha256:b5ec275f0904a0a882d27e1434efb28e0595a74c6c0814297b2537fa49833f56",
  "collector-id": "bash",
  "outcome": "not-satisfied",
  "time": "2026-11-03T06:00:04Z",
  "observation": {
    "facts": {
      "sshd.ciphers": ["chacha20-poly1305@openssh.com",
                       "aes256-gcm@openssh.com", "aes256-ctr", "aes128-cbc"]
    }
  },
  "evidence-record": {
    "ref": "evidence/sha256/61c0ab97f7c9033b00b61a1eb09b5aa40d648114422ffa040aa779b09a9118fc",
    "digest": "sha256:61c0ab97f7c9033b00b61a1eb09b5aa40d648114422ffa040aa779b09a9118fc"
  }
}
{
  "id": "https://cso.example/finding/bastion-01-ssh-cbc",
  "assessment-ref": "https://cso.example/assessment/bastion-01-2026-11-03",
  "requirement-ref": "https://cso.example/req/LNX-SSH-1",
  "statement-ref": "s2",
  "check-ref": "https://cso.example/check/LNX-SSH-1-ciphers",
  "state": "closed",
  "actions": [
    { "description": { "en": "Remove aes128-cbc from the Ciphers line of sshd_config; the next daily run verifies." },
      "status": "done" }
  ]
}
excerpts · jascon/examples

What the example bundle records

  • 3 November: four authentication attempts against a bound of four, satisfied. The cipher list contains aes128-cbc, not satisfied. The Assessment's result is the aggregate of its rows.
  • A Finding against clause s2 points to the check that raised it. Its action: remove the cipher.
  • 10 November: both rows satisfied. The Finding is closed and relates to the run that verified it.

The example assessed no real host. Each run executed the bash collector of the Check, unchanged, against a stub sshd that prints a fixed configuration, and every evidence record says so.

Open the example in the app's Checks page

04 The comparators

Twelve, and a list of what is left out

The set is small on purpose. A check that does not fit stays manual and is counted.

  • The criteria are a conjunction. There is no OR, no NOT and no nesting; alternatives of a value are one-of, and negation lives in the operator pairs.
  • No arithmetic and no comparison between two facts. Counting and deriving are work of the collector.
  • The combination is strong Kleene AND: one definite failure decides, and a failure is never hidden behind an unknown elsewhere.
  • An unbound parameter gives inconclusive. A default is never substituted.
  • at-most never binds a parameter that tightens upward, so that tightening a parameter cannot loosen a check.
  • A check over many resources passes only if every applicable one passes. Every resource is evaluated, none is skipped after the first failure, and the verdict comes with the count and the share: "12 of 200 applicable bucket resources not satisfied (6 %)".
OperatorOnHolds when
equalsone valuethe value equals the expected one; decimals by value
not-equalsone valuethe value differs from the expected one; inconclusive on a missing fact
one-ofone valuethe value is in the list
at-least at-mostinteger, decimalordering; decimals never as floats
present absentany factthe key is, or is not, in the observation
includes-alla listevery listed value occurs
excludes-alla listno listed value occurs
subset-ofa listevery observed value is listed
matches matches-notstring, codethe whole value matches an I-Regexp pattern, or none does

Why a regular expression is allowed

The handbook rejects expression languages, because two conformant tools may then return two verdicts. Python, .NET and JavaScript disagree on exactly the constructs people reach for: \d, \w, anchors, flags, lookaround. The dialect is therefore I-Regexp (RFC 9485), built by the IETF for interoperability and used by JSONPath.

What the kernel fixes beyond the RFC

  • A pattern matches the whole value. ^ and $ are ordinary characters.
  • Limits: 256 characters per pattern, 1,000 states, 4,096 characters per value. Beyond that the row is inconclusive.
  • No host engine. Each implementation parses the grammar itself, as RFC 9485 publishes it, and matches without backtracking, so a pattern cannot stall a validator.
  • One dependence is left and stated: a Unicode category \p{..} is read from the host's database (backlog 59).

05 Evidence

Every link verifies offline

Evidence is a directory beside the content manifest. Every file is named by the SHA-256 of its bytes. Redaction happens before hashing, and raw output is a separate file, so a retention delete leaves the record verifiable: the validator reports the file as withheld.

06 Measured fit

481 of 510 rules fit the declarative form

The comparator set was drafted first and measured afterwards, against two open check corpora: the four CIS profiles for Ubuntu 24.04 in ComplianceAsCode (510 rules) and the CIS 1.12 checks of kube-bench (103 automated, 28 manual).

ClassRules of 510
Fits23 of them only if the collector resolves effective values and reports mode bits as flag sets481
Needs arithmeticcounts, uniqueness, time against now12
Needs a comparison between two facts9
Needs OR across facts6
Needs version ordering2
Needs a regex outside I-Regexp0

What the census shows measured, fit by judgement

  • The comparison side is small and the logic sits on the collection side. In 126 hand-written OVAL definitions the states compare with equals 99 times, with a pattern 23 times and with an ordering 41 times.
  • Of 491 regular expressions, 23 are on the comparison side. All 23 are inside I-Regexp or can be rewritten mechanically.
  • Of the 21 OR checks in kube-bench, 16 read "flag absent or flag equals value". A collector that reports the effective value turns them into one comparison.

What it corrected

The set as drafted had no not-equal. The census found it twice in the OVAL states and 85 times across all kube-bench directories, and for a number nothing else says it. It was added on 12 November as the twelfth comparator. The 29 rules that do not fit stay manual.

Census scripts and raw counts

07 State

Accepted for 2.0.0, green in both validators

On 12 November 2026 the author decided the open points of the proposal. Check has been part of the release candidate since 2.0.0-rc.2 and goes live with 2.0.0. The candidate, now rc.4, is not tagged.

In the repository

measured
  • Schema and rules: the Check shape, the run rows on Assessment, the reference on Finding, the evidence record, the facet collector@1; CHECK-1 to CHECK-15 and the primitive check-verdict, each with a rationale that prints on failure.
  • 205 conformance vectors pass in the Python reference, in the PowerShell twin on Windows PowerShell 5.1 and in the app's JavaScript port. Five deliberate breaks of the reference each turn a vector red.
  • A worked example with two Checks, two runs, a Finding and seven evidence files.
  • The grammar of RFC 9485 as published, compared on 12 November. It keeps surrogate code points out of patterns, which the working group's file did not; the three engines were corrected and five vectors pin it.
  • Text: specification D24, handbook chapter 10 and the validator chapter, appendices A, B and C, and the skill for coding agents.
  • Tools: the app's Checks page writes checks by hand or lets a language model draft them, one rule at a time or for every automated rule of a CIS import. The single-file reader shows Checks and recorded runs.

Open

open
  • No runner. Nothing in the repository executes a collector on a target, and the app does not either. An HTTP collector has no declared request format yet.
  • No cloud platform counted. The census covers Linux hosts and Kubernetes. The shape closes at the tag on those two.
  • One open choice: whether a Unicode category in a pattern follows the host's database or a pinned table.
Question put to the authorDecision of 12 November 2026
The promotion rule asks that two of three census authorities encode a type. None encodes a check.The rule gained a clause for types that catalogue authorities do not publish: a recognised standard requires the record, or it is established practice shown by two counted open implementations; the other two tests hold; it rides a major version. Risk enters under the first branch, Check under the second.
Run rows: kernel field or facet?Kernel field. A verdict is computation, and facets never define computation.
May a Check ship without the requirement it refers to?Yes. A check pack for a catalogue that may not be passed on validates on its own.
Land now, or wait for a cloud API census?Check goes live with 2.0.0.
A quantifier beside "every resource"?None. Every resource is evaluated and recorded, the share of failures is reported, and the check fails.
A twelfth comparator not-equals?Added.

The proposal with its census, the alternative that was not taken (criteria in a facet, promotion later) and the record of the decisions: drafts/CP-CHECK-1.md. The normative text: specification 2.0.0-rc.4, D24.

Review it before the tag closes the shape

A kernel type is paid for by every validator for ever, and a correction after the tag costs a major version. The candidate needs readers who run scanners for a living: does the fact contract hold for your platform, and which of your checks falls outside twelve comparators?