Local-first · Deterministic · Embeddable

Cribra

Sensitive data.
Under control.

An embeddable, local-first Rust engine for deterministic sensitive-data detection, validation, and safe transformation.

The engine, inside your application

Why Cribra?

Keep data local.

Process caller-provided text without a network service. Your application controls where data comes from and where it goes.

Make behavior predictable.

Synchronous execution, deterministic classification, and explicit contracts. No async runtime required.

Choose what happens next.

Review structured results, query findings, or transform a derivative. Storage, sharing, and application policy remain yours.

One reusable Rust core

Core capabilities

Detect and validate: Built-in and custom rules, deterministic and contextual validators, explicit opt-in catalogs.
Report and review: Metadata-only findings, separate review candidates, coordinates, explanations, queries, and summaries.
Scan in context: Whole sources, admitted append-only streams, and revisioned incremental documents.
Transform explicitly: Redaction, templates, keyed pseudonymization, deterministic synthesis, and Share Bundles.

Rust Core provides scanning and reporting; default Flow adds transformations; Fuse adds Serde and optional parallel scans of independent sources. Choose a profile →

Input → engine → application-controlled output

How Cribra works

Caller-provided input
Detection
Validation
Structured results

Your application chooses the paths it needs:

Inspect

Findings, classifications, and reports.
Review

Candidates, when present, requiring explicit decisions.
Transform

Explicitly select a supported transformation to produce derived output.
Share

Explicitly prepare an in-memory Share Bundle using the documented API and original sources.

Review-only candidates are not automatically transformed. Share Bundle preparation is a separate, explicit API operation, not an automatic step after transformation.

Your application owns acquisition, persistence, networking, and sharing. Derived output may still contain sensitive information. Understand the boundary →

Embed the same semantics

Language integrations

Implementation, qualification, distribution, and capability coverage vary by integration. A local binding or CI artifact is not automatically a published package.

Compare integration evidence →

A few lines of Rust

Getting started

Add cribra = "0.7.2" to your dependencies. Configure a scanner and supply the text your application owns.

use cribra::{Rule, Scanner, Severity};

let scanner = Scanner::builder()
    .rule(Rule::prefix("acme.api-key", "acme_live_", Severity::Critical))
    .build()?;

let results = scanner.scan([
    ("config.env", "ACME_API_KEY=acme_live_7f3a91\n"),
]);

for (source, finding) in results.findings() {
    println!("{source}: {}", finding.rule_id());
}

Synthetic custom-rule input; excerpted from the runnable Rust example. The quick start includes a complete program.

Build on explicit contracts.

Start with the concepts, then explore runnable integrations.

Read the documentation →Explore examples →