Algorithm reference

Masks an email address by treating each half separately: the part before the @ (the name) and the domain after it. Each half has its own strategy, which lets you fully anonymize the user while keeping the domain — preserving the per-company distribution your reports rely on.

Generates a synthetic phone number preserving the original formatting exactly: parentheses, spaces, hyphens and digit count all stay in place. Only the digits change — and not all of them: the algorithm tends to preserve prefixes that identify the format (the area code).

Replaces a simple name — just a first name, or just a surname — with another drawn from a lookup file. The draw is a hash of (value + key), so the same name always maps to the same substitute: "John" will be "Thomas" across every table in the project, which keeps name-based joins working. For compound names use Full Name (§1.4).

Splits a full name into first name(s) and surname, then applies a different algorithm to each part. It is an orchestrator: it masks nothing itself, it only decides where the given name ends and the surname begins, delegating each piece to the algorithm you point it at.

Masks Brazilian CPF and CNPJ numbers, generating synthetic values that remain mathematically valid — the check digits are recalculated. The type is detected automatically from the digit count: 11 is a CPF, 14 is a CNPJ. Input formatting (dots, slash, hyphen) is preserved in the output.

Shifts the date by an amount drawn from [minRange, maxRange]. The draw is deterministic by key, so the same date always gets the same shift — which preserves chronological order across records. It is the algorithm of choice when analyses depend on intervals ("days between order and delivery").

A variant of Date Shift where the shift comes not from a continuous range but from a finite set of allowed values defined in a configuration file. Useful when the business requires standardized shifts — for instance, only multiples of 7 days, to preserve the day of the week.

No parameters exposed in the schema — the set of shifts comes from the plugin's built-in configuration.

Discards the original date and draws an absolute date within [minDate, maxDate]. Unlike Date Shift, there is no relationship between input and output beyond determinism — the original chronological order is destroyed. Use it when the date itself is sensitive and no temporal analysis depends on it.

Not really masking, but range clamping: dates inside the range pass through untouched; dates outside are pulled to the nearest bound. The typical use is suppressing outliers that identify individuals — the centenarian customer, the 1900 sentinel date.

Maps a number to another one within [minValue, maxValue], deterministically. Each source value consistently receives the same destination, which preserves joins and distinct counts — but neither order nor magnitude.

The numeric counterpart of Min/Max Date/Time: clamps the value to a range, letting anything already inside pass through untouched. It serves to flatten outliers — very high salaries, extreme negative balances — that on their own identify a person.

The most open-ended algorithm in the set: it evaluates a one-line Java expression over the input value. The expression receives two variables — input (the value as a BigDecimal) and seed (a long derived from the key, for deterministic masking) — plus any constants you declare.

A fixed rule with no configuration: it takes the last 4 digits of the number and replaces them all with the first of those digits, repeated four times. The rest of the number stays intact. This is weak masking, suitable for low-sensitivity fields where you only want to break the exact value.

None. The behavior is fixed.

Swaps each character for another from the same group. You define the groups (lowercase letters, uppercase, digits…) and the algorithm guarantees a letter becomes a letter and a digit becomes a digit, preserving length and the "visual shape" of the data. Characters belonging to no group — spaces, accents, punctuation — pass through untouched.

Applies character-by-character substitution rules: each rule declares which characters to detect and what to replace them with. Unlike Character Mapping, the substitution here is fixed (not drawn) — every filtered character becomes the same symbol. It can optionally run after another algorithm, via stringAlgorithm.

Splits the string into fixed-length segments and handles each one independently — mask, preserve, or replace with a constant. This is the right algorithm for rigidly formatted documents where different parts carry different meaning: CPF, CNPJ, postal code, barcode, account number with an embedded branch code.

The most flexible algorithm for structured text. You define regex patterns; the first one matching the entire string is applied, and each capture group (parentheses) receives an independent action — preserve, drop, redact, or pass through another algorithm. Text between groups is preserved automatically.

{"maskPatterns": [
  { "regex": "(.+@.+)",
    "actions": [{"type":"APPLY_ALGORITHM","algorithm":{"name":"dlpx-core:Email SL"}}] },
  { "regex": "(.+)",
    "actions": [{"type":"APPLY_ALGORITHM","algorithm":{"name":"dlpx-core:FirstName"}}] }
]}

Chains algorithms in sequence: the output of one becomes the input of the next. It requires at least two. Use it to compose transformations no single algorithm offers — mask then normalize, or apply two layers of substitution.

Redistributes values across records: each row receives a value that belonged to another. No value is invented — the set stays identical, only the associations change. This perfectly preserves the column's statistical distribution, making it ideal for columns used in aggregations.

Scans free text for sensitive entities — by regular expression and/or by a list of terms in a file — and replaces only the matched stretches. Everything else is preserved, keeping the document readable and useful for analysis.

A simpler, more direct take on redaction: a map of regex → replacement text. Each map key is a pattern, and the corresponding value is what takes its place. With no regex configured, it returns the input value with no masking at all.

Masks card numbers while preserving the BIN (the leading digits identifying the network and issuer) and, optionally, the trailing digits used in reconciliation. The generated number keeps a valid Luhn check digit, so it still passes form and system validation.

Masks an IBAN while preserving the country code and recalculating the check digits, so the result remains a structurally valid IBAN. You control how many characters of the national part get shuffled.

Replaces the value with a line from a lookup file, chosen by hashing (value + key). The same input always selects the same line, which gives referential consistency across tables without needing a mapping database. It is the plugin's most widely used lookup algorithm.

A variant of Secure Lookup with explicit null handling: null input returns null instead of raising an error. It exposes no parameters — it uses the lookup file embedded in the plugin.

None.

Substitutes values according to an explicit lookup table: you declare exactly which value becomes which. Unlike Secure Lookup, there is no hashing or drawing. In practice it is more a standardization tool than a masking one — normalizing abbreviations, unifying divergent spellings.

Maintains a persistent one-to-one mapping in a database: each original value receives a unique substitute, stored and reused across every table and every future run. It is the plugin's strongest guarantee of referential consistency — and the only one that survives between separate jobs.

Chooses which algorithm to apply to each column based on the value of a conditional column. The classic case: if the gender column says "F", mask the name with a list of female names; if "M", with male names — keeping the record internally coherent.

Masks address fields spread across several columns — street, number, district, city, state, postal code — generating a synthetic address that is internally coherent. Without it, masking each column in isolation would produce impossible combinations (a California street with a New York ZIP code).

Not documented in this guide — the algorithm does not initialize without the address file, which prevents inspecting its schema in the runner.

Masks numbers carrying a check digit and recalculates that digit afterwards, so the result still passes validation. It is generic: any weighted-sum-plus-modulus scheme can be described through its parameters — barcode, EAN, payment slip, registration number, state tax ID.

The only reversible algorithm in the set. It encrypts the value with AES and returns a token; with the same key and configuration, the original value can be recovered (in the Tester, via the Detokenize button — REIDENTIFY mode). It is the choice when the data must return to its original form somewhere in the pipeline.