Skip to main content
Version: 2.22.0

Configuring NITF and NSIF protection

Glasswall Halo protects NITF (National Imagery Transmission Format) and NSIF (NATO Secondary Imagery Format) files with Glasswall Genesis. You control that protection through the optional extendedFormatSettings section of a content management policy, by setting the action Genesis takes for each rule. This page explains the section, lists every rule with its default action and describes the default behavior you will see in protected files.

The section is managed through the Policy management API and the dynamic policy of a CDR request. It does not appear in the Halo Portal in this release. For the policy endpoints and the three ways to apply a policy, see Define content management policies.

The default​

A newly created or reset policy carries an empty policy tree:

"extendedFormatSettings": {
"version": 1,
"policy": {}
}

An empty tree, or no extendedFormatSettings section at all, means Genesis applies its own default action to every rule. The default for each rule is listed in the NITF rule reference.

Example​

Each entry under rules names a rule, by its name or its ID, and gives the one action it takes. Every rule you do not name keeps its default.

"extendedFormatSettings": {
"version": 1,
"policy": {
"cdr": {
"globals": {},
"overrides": {
"nitf": {
"rules": {
"originator-name-disclosure": "report",
"originator-phone-disclosure": "report",
"gw-7NHJA9B": "report",
"image-subheader-unaccounted-bytes": "remove"
}
}
}
}
}
}

This policy keeps the originator name and phone fields and the file title, which Genesis would otherwise overwrite, and removes surplus bytes from image subheaders, which Genesis would otherwise only report. The empty globals object is required in this release whenever cdr is present.

Settings reference​

Envelope​

SettingTypeDefaultEffect
versioninteger1The version of the section's shape. Always 1 in this release.
policyobject{}The Genesis policy tree. Halo hands it to Genesis unchanged. Empty means Genesis defaults.

Policy tree​

SettingWhereEffect
cdrpolicyThe Glasswall CDR (Content Disarm and Reconstruction) decisions. This is the only section Halo enforces.
globalspolicy.cdrRequired whenever cdr is present. May be an empty object, as in the example.
overridespolicy.cdrPer-format settings, keyed by format. The format keys are nitf for the NITF or NSIF file itself, and jpeg, jpeg2000, emf, wmf, h264, h265 and sidd for the content embedded in it. Any other key is rejected when the policy is saved.
rulesoverrides.<format>The action for individual rules, keyed by rule name or rule ID. The value is one action, written as a string. The rule must offer the action you name, or the policy fails when Genesis loads it.

The section also accepts scope-wide settings, such as compliance and per-content-type actions, under globals and under each override. They are not covered in this release.

Actions​

ActionEffect
reportRecord the finding in the analysis report and deliver the file with the content unchanged.
revealMake hidden content visible. No NITF rule offers this action in this release.
replaceOverwrite the content with a safe value, for example spaces or a default.
removeRemove the content and correct the lengths that described it.
rejectBlock the file. The file is not delivered and the report gives the reason. Every rule offers this action.
omitDo not run the rule. Nothing is reported and nothing is changed.

Setting null for a rule is the same as leaving it out.

How a rule's action is decided​

A rule takes the action its rules entry names. Without an entry it takes its default. A rule that offers only reject, such as image-subheader-length-mismatch, cannot be changed, and a policy naming another action for it is rejected when Genesis loads it. Where several rules act on the same field, they run in order and the last one sets the final value.

Default behavior you will see in output​

Some rules change a field on every protected file, and some fields are handled in ways that cannot be configured.

  • Originator name and phone (ONAME, OPHONE) are overwritten with spaces on every protected file. Set originator-name-disclosure and originator-phone-disclosure to report to keep them.
  • File title, text segment titles and graphic names (FTITLE, TXTITL, SNAME) are replaced because they can carry sensitive free text. Set file-title-disclosure, text-title-disclosure or graphic-name-disclosure to report to keep them.
  • Encryption flag (ENCRYP) is never rewritten. A file whose flag is set to anything other than 0 is blocked, because clearing it would deliver a file that claims to be unencrypted while carrying the original bytes. To take delivery of such a file, set encryption-flag-invalid and encryption-flag-segment-invalid to report. A blank flag is treated as unset, and its departure from the numeric character set is reported by header-numeric-charset-invalid.
  • Image sync (ISYNC) is overwritten with zero and the file is delivered. Set image-sync-invalid to reject to block such a file instead.
  • Reserved segment count (NUMX) blocks the file when it is not 000. Set label-segment-count-out-of-range to replace to have it overwritten and the file delivered, or to report to deliver the file unchanged.
  • Copy numbers (FSCOP, FSCPYS) are overwritten with 00000 on every protected file by copy-numbers-non-default. Because the block decision reads the corrected output, that overwrite also satisfies copy-numbers-not-integer, so a reject on that rule only takes effect where the overwrite is suppressed. To block on non-default copy numbers, set copy-numbers-non-default itself to reject.
  • Image subheader length. Where an image subheader's fields need more space than the declared length provides, image-subheader-length-mismatch blocks the file, and that cannot be changed. Where the declared length exceeds the fields, image-subheader-unaccounted-bytes reports the surplus by default. Setting it to remove deletes the surplus and corrects the subheader and file lengths, which shortens the file. Some producers pad subheaders, so the reporting default is recommended unless the surplus must go.
  • Compressed images, CGM graphics and SIDD segments are handed to the matching embedded format by the rules compressed-image-present, cgm-content-present and des-data-present. Setting one of them to report delivers that content uninspected.
  • Output integrity. After protection, Genesis re-reads every output file and refuses to deliver one it can no longer parse as valid NITF. This check cannot be turned off.
  • SIDD and other XML segments. A SIDD segment that cannot be protected blocks the whole file with the reason unsupported-variant, and this is not configurable. A non-SIDD XML segment such as SICD is blocked by unsupported-xml-des, which you can downgrade to report to pass the segment through uninspected.

Choosing a non-modifying action such as report or reject for a rule turns off the replacement that rule owns, so the field is delivered as it arrived.

Declassification fields and the classification text field​

The declass-fields-present rule clears the declassification fields when the element is unclassified or declares no declassification type, following the Inspection and Sanitization Guidance. The guidance groups six fields for this purpose: the declassification type, date and exemption, the downgrade indicator and its date and the classification text field (xSCLTX).

Genesis clears the first five and filters the sixth rather than clearing it. The classification text field is where a file records dissemination caveats when the control-and-handling field holds CH, and where codeword and releasability overflow is held. A blank declassification type is the specification's default, so clearing the field on that basis would strip caveats from classified products that simply never declared a declassification scheme.

The filter keeps only the formatted values the guidance defines for the field, and only when the field that declares the overflow agrees:

  • A CW_ codeword overflow, when the codewords field ends in +.
  • An RL_ releasability overflow, when the releasability field ends in +.
  • CH_ caveats or SIC: indicator codes, when the control-and-handling field holds CH.
  • Either "CANNOT BE EXPRESSED IN SUBHEADER" declaration.

Everything else in the field is cleared. In practice this means dissemination caveats survive processing, free text in the field is still removed and a field holding a caveat followed by free text is rewritten to the caveat alone. classification-text-disclosure reports the original content before processing.

To have the declassification fields reported instead of cleared, set declass-fields-present to report. Setting classification-text-disclosure to reject blocks any file whose classification text field carries content, because it is a presence check with no replacement available.

Embedded content​

A NITF or NSIF file can carry images, graphics and video that Genesis inspects with the format's own rules. You set their actions in the same way, under overrides.<format>.rules, where the format is jpeg, jpeg2000, emf, wmf, h264, h265 or sidd. Every rule for these formats, with its default action, is listed in NITF and NSIF embedded content rules.

These settings apply only to content inside a NITF or NSIF file. A standalone file of one of these formats is not processed by Genesis. Where the Glasswall Embedded Engine supports the format, it is configured through contentManagementFlags instead.

Validation and errors​

Halo checks the cdr section against the settings and values Genesis accepts before it stores a policy or accepts a request.

  • An unknown setting or a value outside the allowed set is rejected with error code 4004 and a message naming the path to the setting at fault.
  • A cdr section without globals is rejected with error code 4004.
  • An overrides key that is not one of the eight formats is rejected when the policy is saved.
  • Rule names are not checked by Halo. A name Genesis does not recognize, or an action the rule does not offer, is found when Genesis loads the policy. Every NITF or NSIF file submitted under that policy is then errored with the reason GenesisPolicyInvalid until the policy is corrected.
  • The policy is read for every request, so a change takes effect for the next submission without redeploying or restarting Halo.

NITF rule reference​

Every rule Genesis applies to the NITF structure, grouped by the part of the file it checks. Target a rule under rules by its name or its ID. reject is offered by every rule and is not repeated in the Configurable actions column. Compliance lists the sources that back the rule: spec is the format specification, isg is the NSA Inspection and Sanitization Guidance, cve is a published vulnerability, gw is Glasswall research. Impact is the rule's change tier.

allowed-character-sets-size​

If any byte in a file header field falls outside the declared character set, it may indicate data hiding, corruption or an attack vector. Fields using BCS-A, BCS-N, BCS-N PI and ECS-A each have specific allowed byte ranges defined by the NITF specification.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
file-datetime-charset-invalidgw-KBZF59JDetect BCS-N fields containing characters other than digits, plus, minus, period or slashrejectreport omitspec; isg; gwfunctional
file-header-fields-charset-invalidgw-MJ1JYW4Detect BCS-A fields containing bytes outside the range 0x20-0x7Erejectreport omitspec; isg; gwfunctional
header-length-charset-invalidgw-77NRM2FDetect a file length or header length field containing characters other than digitsrejectreport omitspec; isg; gwfunctional
header-numeric-charset-invalidgw-D5RH2V3Detect a complexity level, copy number or encryption field with characters other than digitsreportreport omitspec; isg; gwfunctional
header-text-fields-charset-invalidgw-VBGAZ4PDetect ECS-A fields containing bytes outside the ranges 0x20-0x7E or 0xA0-0xFFrejectreport omitspec; isg; gwfunctional

band-representation​

Inconsistent band representation descriptors may indicate a manipulated file designed to hide content in bands that standard viewers ignore.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
band-count-inconsistentgw-62P1GAJDetect a band count (NBANDS/XBANDS) inconsistency: NBANDS outside 0-9, or XBANDS missing when NBANDS is 0rejectreport omitspec; isg; gwfunctional
band-representation-invalidgw-B33PP90Detect band representation (IREPBANDn) values inconsistent with IREPrejectreport omitspec; isg; gwfunctional
band-subcategory-invalidgw-YA9NG6WDetect band subcategory (ISUBCATn) values inconsistent with ICAT and IREP (Table 5.13-8)rejectreport omitspec; isg; gwfunctional
lookup-table-embedded-filegw-H0HJXKXDetect a file signature embedded in a band lookup table's entriesrejectreport omitisg; gwfunctional
lookup-table-size-invalidgw-988T966Detect a band lookup table whose declared size is outside what the spec permitsrejectreport omitspec; isg; gwfunctional

classification​

Invalid classification values or missing classification system codes may indicate manipulation or cause mishandling of classified information. Security classification fields may contain sensitive information about classification handling and releasability.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
classification-level-inconsistentgw-TX2K4D9Detect a segment classification that exceeds the file header classification (U < R < C < S < T)rejectreport omitspec; isg; gwfunctional
classification-level-invalidgw-E2HB506Detect an xSCLAS value other than T, S, C, R or U in the file header or any segment subheaderrejectreport omitspec; isg; gwfunctional
classification-system-bare-country-invalidgw-ZCFM2D6Detect an xSCLSY bare country code that is neither valid a priori (uppercase A-Z only) nor ad hoc (letters and digits) formatrejectreport omitspec; isg; gwfunctional
classification-system-conditional-invalidgw-VRBP79TDetect an xSCLSY of spaces when xSCLAS is T/S/C/R (classified)rejectreport omitspec; isg; gwfunctional
classification-system-country-invalidgw-P9RVRXRDetect an xSCLSY that is not a valid 2-byte country code (uppercase A-Z), special code (XN/XF/YY/UU) or spaces when unclassifiedrejectreport omitspec; isg; gwfunctional
classification-text-country-invalidgw-YX23VPPDetect an xSCLTX fully specified country code URN with invalid concept-type, authority, encoding, baseline or code componentsrejectreport omitspec; isg; gwfunctional
codewords-disclosuregw-W7SFNG0Detect codewords (xSCODE) carrying content the conformance check does not constrainreportreport omitisg; gwfunctional
codewords-invalidgw-5BGEHYEDetect an xSCODE that is not spaces, ISM-IN-TRE-, ISM-IN-FHDR or space-separated codewords of printable charactersrejectreport omitspec; isg; gwfunctional
control-handling-invalidgw-EH9AHWGDetect an xSCTLH that is neither spaces nor 2 BCS-A printable charactersrejectreport omitspec; isg; gwfunctional
control-handling-marking-conflictgw-8HVEZYXDetect an xSCTLH of CH while xSCODE stores the markings externallyreportreport omitspec; gwfunctional
control-handling-overflow-missinggw-KSHF9Z2Detect an xSCTLH of CH whose xSCLTX is not a CH_ or SIC: code overflowreportreport omitspec; gwfunctional
releasing-instructions-invalidgw-06P0AXYDetect an xSREL that is not spaces, hash-fill or space-separated bare country codes (2-3 uppercase A-Z chars, 20th char may be +)rejectreport omitspec; isg; gwfunctional
segment-codewords-undeclaredgw-JA5C7JVDetect codewords in a segment subheader that the file header does not declarereportreport omitgwfunctional
segment-control-handling-undeclaredgw-TC4KJXPDetect control and handling markings in a segment subheader that the file header does not declarereportreport omitgwfunctional
segment-releasability-undeclaredgw-1DFE95GDetect releasing instructions in a segment subheader that the file header does not declarereportreport omitgwfunctional

classification-authority​

Invalid classification authority fields may indicate file manipulation or cause improper attribution of classification decisions. Classification authority field may contain personally identifiable information about the classifying official.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
authority-type-invalidgw-BH8SF9KDetect an xSCATP other than O, D, M or spacerejectreport omitspec; isg; gwfunctional
classification-authority-disclosuregw-EZ337WVDetect classification authority (xSCAUT) carrying free text that requires reviewreportreport omitisg; gwfunctional
classification-reason-invalidgw-HTW43F6Detect an xSCRSN other than A-H, M, N or spacerejectreport omitspec; isg; gwfunctional
copy-number-inconsistentgw-VS8J12TDetect a file copy number (FSCOP) greater than the file number of copies (FSCPYS)rejectreport omitspec; isg; gwfunctional
security-source-date-invalidgw-93KG1R2Detect an xSSRDT that is neither a valid CCYYMMDD nor all spacesrejectreport omitspec; isg; gwfunctional

data-extension-segment​

DES subheader fields may contain forged data. DE must be 'DE', DESID must be printable and DESVER must be valid.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
des-body-opaquegw-KZ1JQSMDetect a non-SIDD DES carrying an opaque, uninspectable bodyreportreport replace omitisg; gwfunctional
des-body-smuggling-signalgw-6V4DAZGDetect a non-SIDD DES body (DESDATA/DESSHF) carrying a content-smuggling signalreportreport replace omitspec; isg; gwfunctional
des-data-embedded-filegw-FFK1XHHDetect Data Extension Segment data carrying an embedded file signature other than markuprejectreport omitspec; isg; gwfunctional
des-data-embedded-markupgw-PHN7MJVDetect Data Extension Segment data carrying an embedded XML or HTML signaturereportreport omitisg; gwfunctional
des-data-entropy-suspiciousgw-AS5VX71Detect DES data with anomalously high entropy indicating hidden or encrypted contentreportreport omitspec; isg; gwfunctional
des-data-null-paddinggw-15MB867Detect DES data carrying null padding that may conceal hidden contentreportreport omitspec; isg; gwfunctional
des-data-presentgw-C63HQ8ADetect SIDD (Sensor Independent Derived Data) DES segments (DESID 'XML_DATA_CONTENT' with SIDD subspec) whose embedded XML requires sub-camera inspectionreplacereplace report omitisg; gwfunctional
des-data-printable-ratio-suspiciousgw-6QV26WKDetect DES data with an anomalous printable-character ratioreportreport omitspec; isg; gwfunctional
des-id-invalidgw-DVR7GTCDetect a DES identifier (DESID) containing non-BCS-A bytesreportreport omitspec; isg; gwfunctional
des-identifier-spoofedgw-QRQM2BNDetect a DES identifier (DESID) impersonating a dedicated-handler identifier through non-conformant paddingrejectreport omitspec; gwfunctional
des-name-collision-setgw-SXAC10YDetect XML element names chosen to share a hash value, degrading a consumer's lookupreportreport omitspec; isg; gwstructural
des-subheader-length-mismatchgw-8285Q3FDetect a DES subheader length (LDSH) that disagrees with the length DESSHL impliesrejectreport omitspec; isg; gwfunctional
des-type-invalidgw-3B8RZ5SDetect a DES subheader file part type (DE) other than 'DE'reportreport omitspec; isg; gwfunctional
des-unregisteredgw-GP8DGJ5Detect a DES identifier (DESID) that is not registered in the NTB FV-CP registerreportreport omitspec; isg; gwfunctional
des-user-header-field-invalidgw-CAZQ6YDDetect an XML DES user-defined subheader subfield that violates its declared type or rangereportreport omitspec; gwfunctional
des-user-header-length-invalidgw-TWEAMEMDetect an XML DES user-defined subheader length that is not a defined inclusion stagereportreport omitspec; gwfunctional
des-version-invalidgw-H3SJZT6Detect a DES version (DESVER) that is not a valid 2-digit version number (01-99)reportreport omitspec; isg; gwfunctional
multiple-sidd-desgw-WY5HYF6Detect a container declaring more than one SIDD XML data extension segmentreportreport omitisg; gwfunctional
streaming-des-field-unsupportedgw-39QNDBXDetect a STREAMING_FILE_HEADER present in any DES DESID fieldrejectreport omitspec; isg; gwfunctional
unsupported-xml-desgw-NTFXDESDetect an XML_DATA_CONTENT / SIDD_XML DES whose XML root is not a SIDD namespace (an unsupported variant such as SICD that the SIDD sub-camera cannot inspect or remediate)rejectreport omitisg; gwfunctional

declassification​

Invalid declassification fields may indicate file manipulation or cause mishandling of declassification schedules. Classification text may contain sensitive information about classification reasoning and authority.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
classification-text-disclosuregw-J0N4J9JDetect classification text (xSCLTX) carrying free text that requires reviewreportreport omitisg; gwfunctional
declass-date-conditional-invalidgw-9PJZBJ4Detect an xSDCDT of spaces when xSDCTP is DD or DErejectreport omitspec; isg; gwfunctional
declass-date-format-invalidgw-64DJ90QDetect an xSDCDT that is neither a valid CCYYMMDD nor all spacesrejectreport omitspec; isg; gwfunctional
declass-exemption-invalidgw-JN916GMDetect an xSDCXM that is not a valid exemption code when xSDCTP is X(space)rejectreport omitspec; isg; gwfunctional
declass-fields-presentgw-Y605Q6JDetect declassification fields (FSDCTP, FSDCDT) populated when classification is U or the declassification type is not implementedreplacereplace report omitisg; gwfunctional
declass-type-invalidgw-0B1ZGMNDetect an xSDCTP other than DD, DE, GD, GE, O(space), X(space) or spacesrejectreport omitspec; isg; gwfunctional
downgrade-date-conditional-invalidgw-C209SXHDetect an xSDGDT that is not a valid CCYYMMDD when xSDG is S/C/Rrejectreport omitspec; isg; gwfunctional
downgrade-invalidgw-5J4ZJJXDetect an xSDG other than S, C, R or spacerejectreport omitspec; isg; gwfunctional
downgrade-level-inconsistentgw-516Q559Detect an xSDG naming a classification at or above xSCLASrejectreport omitspec; isg; gwfunctional
downgrade-without-declass-typegw-Y5TG33SDetect an xSDG populated while xSDCTP is neither GD nor GErejectreport omitspec; isg; gwfunctional

encryption​

Encrypted NITF files cannot be inspected or protected. ENCRYP is defined in the file header (offset 296) and in the Image, Graphic and Text subheaders only; MIL-STD-2500C tables A-8 and A-9 give the DES and RES subheaders no such field. A populated value other than 0 declares the payload to be ciphertext and the file is rejected, since clearing the flag would not decrypt the content and would deliver a file declaring itself unencrypted while carrying the original bytes. An all-spaces field declares nothing and is treated as unset; its departure from BCS-N PI is reported by header-numeric-charset-invalid.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
encryption-flag-invalidgw-T5C81WMDetect a file header encryption flag (ENCRYP) declaring the payload encryptedrejectreport omitspec; isg; gwfunctional
encryption-flag-segment-invalidgw-GHXDFVADetect an encryption flag (ENCRYP) declaring an Image, Graphic or Text payload encryptedrejectreport omitspec; isg; gwfunctional

extended-header-data​

The Extended Header Data fields (XHDL, XHDLOFL, XHD) allow additional TRE data in the file header. Invalid length values or overflow references to non-existent DES segments can hide data or cause incorrect parsing. Extended Header Data (XHD) may contain TRE data with sensitive or classified information that requires external filtering before release.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
ext-header-length-out-of-rangegw-XF0T67KDetect an extended header data length (XHDL) that is neither 0 nor within 3-99999rejectreport omitspec; isg; gwfunctional
ext-header-overflow-invalidgw-RM0YJJQDetect an extended header overflow reference (XHDLOFL) that does not reference a valid DES segmentrejectreport omitspec; isg; gwfunctional
ext-header-presentgw-K3K2J3YDetect extended header (XHD) TRE data that may carry sensitive informationreportreport omitisg; gwfunctional

file-length-and-header-length​

Data can be appended to NITF files by manipulating the FL field to be smaller than the actual file size. Mismatched header length values may indicate malicious modification of the file structure. Applications rely on FL and HL being accurate for correct parsing.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
complexity-level-size-exceededgw-ZZGFZ82Detect a file size (FL) exceeding the maximum allowed by the declared complexity level (CLEVEL) per Table G-1reportreport omitspec; isg; gwfunctional
file-length-mismatchgw-HYP7KVGDetect a file length (FL) that does not match the actual file sizerejectreport omitspec; isg; gwfunctional
file-length-out-of-rangegw-VG7SDKEDetect a file length (FL) outside the allowed range (388 to 999999999998)rejectreport omitspec; isg; gwfunctional
header-length-mismatchgw-A2C0B97Detect a header length (HL) that does not match the computed header length (skipped when HL is 999999, streaming mode)rejectreport omitspec; isg; gwfunctional
header-length-out-of-rangegw-QY07JKCDetect a header length (HL) outside the allowed range (388 to 999999)rejectreport omitspec; isg; gwfunctional

graphic-cgm-structure​

CGM graphic data may contain malformed element streams, reserved element classes or security-sensitive Escape (class 6) and Application Data (class 7) elements that can carry arbitrary vendor-specific operations or payloads.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
cgm-content-presentgw-CGMEMB3Detect graphic segments carrying WMF / EMF metafile data whose content requires sub-camera inspectionreplacereplace report omitisg; gwfunctional
cgm-structure-invalidgw-VZ7D0W5Detect a CGM element stream with a structural-integrity fault, missing delimiter or security-sensitive elementrejectreport omitspec; isg; gwfunctional

graphic-extended-data​

SXSHDL defines the size of extended subheader data in graphic segments. Values of 1 or 2 are invalid (must be 0 or 3-99999). Manipulated lengths can cause parsers to read incorrect data. SXSHD TRE data may contain sensitive information that requires external filtering.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
graphic-ext-header-disclosuregw-64JA1PWDetect graphic extended-subheader (SXSHD) TRE free-text content that may carry sensitive informationreportreport omitspec; isg; gwfunctional
graphic-ext-header-length-invalidgw-C903W2ADetect a graphic extended-subheader data length (SXSHDL) that is neither 0 nor 3-99999 in any graphic subheaderreportreport omitspec; isg; gwfunctional

graphic-subheader​

Graphic subheader fields may contain forged or hidden data. SY must be 'SY', SFMT must be 'C' and SSTRUCT must be all zeros. SID and SNAME may disclose sensitive identification information.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
graphic-format-structure-non-defaultgw-JA74Q9RDetect a graphic format (SFMT) other than 'C' (CGM) or a structure (SSTRUCT) other than 13 zerosreplacereplace report omitspec; isg; gwfunctional
graphic-id-name-disclosuregw-8A9BJZ3Detect graphic identifier (SID) and name (SNAME) free-text content that may carry sensitive informationreportreport omitspec; isg; gwfunctional
graphic-name-disclosuregw-853KZBRDetect a graphic name (SNAME) that may carry sensitive informationreplacereplace report omitisg; gwvisual
graphic-partition-invalidgw-BE2E2K6Detect a graphic subheader file part type (SY) other than 'SY'reportreport omitspec; isg; gwfunctional

header-first-119-bytes​

Based on experimentation with uncertified NITF viewers, it appears the only field required to be accurate is the File Profile Name, which should be "NITF". The next bytes of this header portion do not appear to have a significant impact on the file when opening it, so they could contain hidden data or malicious content. The Complexity Level signals to the application the complexity of the file and the requirements necessary to process the file; manipulation of this field may impact the ability for NITF files to be processed by certain applications. Uncertified applications should not be used to process or render NITF files as they can create and/or persist non-compliant NITF files. The NITF header contains the fields Originator's Name, Originator's Phone Number, Originating Station ID and the File Title. All of these fields could contain sensitive information.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
complexity-level-invalidgw-NCTA52ADetect a CLEVEL that does not evaluate to 03, 05, 06, 07, 09, 51, 54 or 57 (any other value is non-compliant; values 51, 54 and 57 imply the file uses the Motion Imagery Extension (MIE4NITF); Table G-1 in JBP 2024.1 covers additional constraints on subsequent constructs based on the value of CLEVEL)rejectreport omitspec; isg; gwfunctional
copy-numbers-non-defaultgw-HMWEEN3Detect a file copy number (FSCOP) / file number of copies (FSCPYS) carrying non-default copy-tracking valuesreplacereplace report omitisg; gwfunctional
copy-numbers-not-integergw-06RZ9KCDetect a file copy number (FSCOP) or file number of copies (FSCPYS) that is not a positive integerrejectreport omitspec; isg; gwfunctional
file-datetime-cross-segment-invalidgw-7JAT2XPDetect a file date/time (FDT) earlier than an image (IDATIM) or text (TXTDT) date/timerejectreport omitspec; isg; gwfunctional
file-datetime-invalidgw-EF4XAH4Detect a date field (FDT) that is not in the correct UTC format of CCYYMMDDhhmmssrejectreport omitspec; isg; gwfunctional
file-header-invalidgw-YGWDXM2Detect a file profile name (FHDR) other than NITF or NSIF in the first 4 bytesrejectreport omitspec; isg; gwfunctional
file-title-disclosuregw-7NHJA9BDetect a file title (FTITLE) that may carry sensitive free textreplacereplace report omitisg; gwvisual
nitf-file-version-invalidgw-WT6EGQ3Detect a file version (FVER) other than 02.10 when the file profile name (FHDR) is NITFrejectreport omitspec; isg; gwfunctional
nsif-file-version-invalidgw-RW8EGH5Detect a file version (FVER) other than 01.01 or 01.00 when the file profile name (FHDR) is NSIFrejectreport omitspec; isg; gwfunctional
originator-fields-disclosuregw-31ANKNTDetect originator name (ONAME), phone (OPHONE), station ID (OSTAID) and file title (FTITLE) free-text content that may carry sensitive informationreportreport omitspec; isg; gwfunctional
standard-type-invalidgw-6RP2YBGDetect a standard type (STYPE) field other than "BF01"rejectreport replace omitspec; isg; gwfunctional

image-block-structure​

Block structure inconsistency (NBPR*NPPBH < NCOLS or NBPC*NPPBV < NROWS) causes downstream decoders to miscalculate buffer sizes, potentially leading to heap buffer overflow or under-read.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
block-cols-mismatchgw-B4ESDK9Detect vertical block coverage (NBPC * NPPBV) less than the image height (NROWS)reportreport omitspec; isg; gwfunctional
block-count-mismatchgw-Q4XHWNKDetect a number of blocks per row (NBPR) or per column (NBPC) below 1reportreport omitspec; isg; gwfunctional
block-rows-mismatchgw-KY9HQSYDetect horizontal block coverage (NBPR * NPPBH) less than the image width (NCOLS)reportreport omitspec; isg; gwfunctional

image-comments​

Image comments (ICOM fields) may contain hidden data via non-printable characters. Each ICOM must consist of BCS-A printable characters (0x20-0x7E). Image comments may contain sensitive information that requires external filtering.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
image-comment-charset-invalidgw-6JG38N8Detect an image comment (ICOM) containing characters other than BCS-A printable (0x20-0x7E)reportreport omitspec; isg; gwfunctional
image-comment-disclosuregw-DNXMCC0Detect image comment (ICOM) free-text content that may carry sensitive informationreportreport omitspec; isg; gwfunctional

image-compression​

Invalid compression codes, missing mask tables or malformed COMRAT values may indicate a manipulated image or trigger codec vulnerabilities.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
codestream-trailing-data-presentgw-C36XZW6Detect data appended after the JPEG 2000 codestream EOCreplacereplace report omitspec; gwstructural
compressed-geometry-mismatchgw-W70TCXDDetect a compressed image whose codestream declares a different picture than its subheaderrejectreport omitspec; isg; gwfunctional
compressed-image-presentgw-NTFEMB5Detect compressed image segments (IC in C3, M3, C5, M5, C8, M8) whose pixel data requires sub-camera inspectionreplacereplace report omitisg; gwvisual
compression-code-invalidgw-FWSZF1ZDetect an image compression code (IC) that is not a permitted valuerejectreport omitspec; isg; gwfunctional
compression-codec-unsupportedgw-K4WQ2M8Detect an image segment whose compression code (IC) is a compressed codec Genesis has no sub-camera to inspect (e.g. C1 bi-level, C4 vector quantization); the codestream cannot be made safe, so protect fails closed rather than blanking the pixels while reporting cleanrejectreport omitspec; gwfunctional
compression-mask-table-presentgw-9Q07H96Detect a masked image compression (IC) without a readable mask table headerreportreport omitspec; isg; gwfunctional
compression-rate-invalidgw-10QM4WEDetect a compression rate (COMRAT) that is malformed when presentreportreport omitspec; isg; gwfunctional
decompressed-size-excessivegw-3KX9WQ2Detect a zlib-compressed image declaring or expanding to more pixel data than the safe limitrejectreport omitspec; gwfunctional
mask-table-structure-invalidgw-FGA40PEDetect an image mask table header field outside the values the spec permits itrejectreport omitspec; isg; gwfunctional
mask-table-unaccounted-bytesgw-ACMSSTNDetect an image mask table declaring image data beyond the fields that describe itremoveremove report omitspec; isg; gwstructural
pixel-data-surplusgw-AWEP9PNDetect an uncompressed image segment carrying more data than its declared pixel array holdsreplacereplace report omitspec; isg; gwstructural
uncompressed-data-length-invalidgw-797K7EKDetect uncompressed (NC/NM) image data shorter than its stored blocks can occupyrejectreport omitspec; isg; gwfunctional

image-dimensions​

Extreme NROWS or NCOLS values can cause integer overflow in dimension*band*bitdepth calculations, leading to heap buffer overflow or excessive memory allocation (DoS). NROWS=0 or NCOLS=0 can cause division-by-zero in stride calculations.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
image-cols-out-of-rangegw-KM2D0K2Detect a number of image columns (NCOLS) below 1 or above the configured maximum (default 65535)rejectreport omitspec; isg; gwfunctional
image-rows-out-of-rangegw-40ESGTZDetect a number of image rows (NROWS) below 1 or above the configured maximum (default 65535)rejectreport omitspec; isg; gwfunctional

image-filter-condition​

IFC values other than 'N' indicate filtered image data. Parsers that do not support the declared filter will misinterpret the image data, potentially causing incorrect rendering or buffer errors. IMFLT carries filter parameters that could be weaponized if non-standard.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
image-filter-condition-invalidgw-YMQBZJ2Detect an image filter condition (IFC) other than 'N' (no filtering applied)reportreport omitspec; isg; gwfunctional
image-filter-invalidgw-QV0EAKJDetect an image filter (IMFLT) other than spaces when the image filter condition (IFC) is 'N'reportreport omitspec; isg; gwfunctional

image-location-magnification​

An attacker could place an unattached image at a non-zero ILOC offset where standard viewers would not display it, hiding content outside the visible CCS origin.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
image-location-invalidgw-5YXKN8GDetect an unattached image placed away from the CCS origin, or an attached image extending beyond its parent segment's bounds (off-canvas data-hiding risk)replacereplace report omitspec; isg; gwfunctional
image-magnification-non-defaultgw-6YNK7GVDetect an image magnification (IMAG) other than the default 1.0replacereplace report omitspec; isg; gwfunctional

image-mode​

Invalid IMODE values or IMODE/IC mismatches may indicate a manipulated file designed to confuse image rendering or exploit codec-specific behavior.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
image-mode-compression-mismatchgw-C2GACCADetect an image mode (IMODE) inconsistent with the compression code (IC)rejectreport omitspec; isg; gwfunctional
image-mode-invalidgw-1GRMF8ZDetect an image mode (IMODE) that is not a permitted valuerejectreport omitspec; isg; gwfunctional

image-segment​

Image subheader fields may contain forged or hidden data. IM must be 'IM', IDATIM must be valid and TGTID must contain valid identifiers. TGTID, IID1 and IID2 may disclose sensitive targeting or identification information.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
image-datetime-cross-segment-invalidgw-Y44FCVQDetect an image date/time (IDATIM) later than the file date/time (FDT)reportreport omitspec; isg; gwfunctional
image-datetime-invalidgw-W6N587PDetect an image date/time (IDATIM) that is not a valid CCYYMMDDhhmmss datetimereportreport omitspec; isg; gwfunctional
image-id-disclosuregw-EX0KMNEDetect target identifier (TGTID) and image identifiers (IID1, IID2) free-text content that may carry sensitive informationreportreport omitspec; isg; gwfunctional
image-partition-invalidgw-2WVT86NDetect an image subheader file part type (IM) other than 'IM'reportreport omitspec; isg; gwfunctional
image-subheader-length-mismatchgw-JQDKW2VDetect an image subheader whose fields do not fit the declared length (LISH)reject—spec; isg; gwfunctional
image-subheader-unaccounted-bytesgw-B75TX7BDetect bytes inside an image subheader that no declared field accounts forreportreport remove omitspec; isg; gwstructural
target-id-invalidgw-NWNFZ76Detect a target identifier (TGTID) with an invalid target identifier or country codereportreport omitspec; isg; gwfunctional

image-source-size-location​

Invalid pixel type, representation or category values may indicate a manipulated or non-compliant image subheader. ISORCE and IGEOLO may disclose sensor identity or geographic targeting information.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
actual-bit-depth-invalidgw-KA2W92QDetect actual bits per pixel (ABPP) inconsistent with the actual image data bit depthrejectreport omitspec; isg; gwfunctional
bit-depth-invalidgw-7K9Z0ZDDetect a number of bits per pixel (NBPP) inconsistent with the actual image data bit depth and compressionrejectreport omitspec; isg; gwfunctional
geographic-coordinates-invalidgw-VXQRRV1Detect a geographic location (IGEOLO) that contradicts the coordinate system ICORDS declaresrejectreport omitspec; isg; gwfunctional
image-category-invalidgw-1YMK6RNDetect an image category (ICAT) that is not a permitted Table A-3 valuerejectreport omitspec; isg; gwfunctional
image-representation-invalidgw-T1VE0Y1Detect an image representation (IREP) that is not a permitted valuereportreport omitspec; isg; gwfunctional
image-source-location-disclosuregw-W8NHN03Detect image source (ISORCE) and geographic location (IGEOLO) free-text content that may carry sensitive informationreportreport omitspec; isg; gwfunctional
pixel-justification-invalidgw-BVD1FYDDetect a pixel justification (PJUST) that is not a permitted valuereportreport omitspec; isg; gwfunctional
pixel-type-invalidgw-SPFHVNEDetect a pixel value type (PVTYPE) that is not a permitted valuerejectreport omitspec; isg; gwfunctional

image-sync​

ISYNC is a reserved field that must always be 0. A non-zero value may indicate data hiding in the reserved field or a corrupted/manipulated file structure.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
image-sync-invalidgw-QCA9R7QDetect a reserved image sync field (ISYNC) other than 0replacereplace report omitspec; isg; gwfunctional

metadata-text​

Metadata text is operator-authored and rendered by downstream consumers, so a script literal or injection sequence hidden there runs where the imagery is displayed. Canonicalization defeats a cloak that splits the literal with an invisible code point.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
metadata-injection-sequencegw-828D9X3Detect a template, expression or SQL injection metacharacter sequence in metadata textreportreport omitcve; gwfunctional
text-active-content-presentgw-VE1TPVMDetect active or executable content in text data or subheader free textrejectreport omitspec; isg; gwfunctional
text-zero-width-character-presentgw-Z2EB4B2Detect an invisible or zero-width Unicode code point in text or subheader free textreportreport omitgw; analogyfunctional

originator-information​

The Originator's Name and Phone Number fields may contain values that do not match an approved whitelist or expected pattern, potentially indicating data hiding or substitution.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
originator-name-disclosuregw-NA9EM24Detect originator name (ONAME) free-text content that may carry sensitive informationreplacereplace report omitspec; isg; gwfunctional
originator-phone-disclosuregw-C2RBSSPDetect originator phone (OPHONE) free-text content that may carry sensitive informationreplacereplace report omitspec; isg; gwfunctional

overflow-des​

Overflow DES segments must have valid DESID='TRE_OVERFLOW' and DESOFLW pointing to a valid overflow source. Overflow DES data contains TRE content that may disclose sensitive information.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
overflow-des-data-disclosuregw-H41BH5JDetect overflow DES TRE free-text content that may carry sensitive informationreportreport omitspec; isg; gwfunctional
overflow-des-id-invalidgw-FS84P3GDetect an overflow DES identifier (DESID) other than 'TRE_OVERFLOW'reportreport omitspec; isg; gwfunctional
overflow-des-target-invalidgw-K9RCTBCDetect an overflow DES source identifier (DESOFLW) that is invalidreportreport omitspec; isg; gwfunctional
overflow-des-type-invalidgw-1RPYRFNDetect an overflow DES subheader file part type (DE) other than 'DE'reportreport omitspec; isg; gwfunctional

polyglot-signature​

A file that is simultaneously valid NITF and a valid second format (DICOM at offset 128, UEFI GPT at 512, ISO 9660 at 32769) is a parser-differential vector: a downstream tool that sniffs the second format processes attacker-chosen content the NITF pipeline never inspected.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
polyglot-signature-presentgw-NY8D1MTDetect a foreign container signature at a fixed file offset that overlays the NITF structurereportreport omitgwfunctional

segment-data​

Segment data may contain hidden or malicious content that requires content review outside the format-specific remediator. An uncompressed pixel array is preserved byte for byte, so a foreign file signature placed at its start is delivered unless it is detected there. Unknown segment types that do not match the expected file part type (IM, SY, TE, DE, RE) must be rejected.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
pixel-data-embedded-filegw-162J4ZMDetect an embedded file signature at the start of uncompressed image pixel datareplacereplace report omitspec; isg; gwvisual
pixel-data-embedded-markupgw-7FWQEKMDetect an embedded XML or HTML signature at the start of uncompressed image pixel datareplacereplace report omitisg; gwvisual
segment-data-embedded-filegw-ZMNWKTCDetect an embedded file signature at the start of graphic or text segment datareportreport replace omitspec; isg; gwvisual
segment-data-embedded-markupgw-H6W4X6CDetect an embedded XML or HTML signature at the start of graphic or text segment datareportreport replace omitisg; gwvisual
segment-data-opaque-payloadgw-GG0HWSNDetect non-image segment payloads (TE, DE, RE) that may carry hidden data or sensitive contentreportreport omitisg; gwfunctional
unknown-segment-typegw-G42ARYVDetect segments with unknown file part typesrejectreport omitspec; isg; gwfunctional

segment-display-level​

Display and attachment levels define how image, graphic and text segments are layered when the file is rendered. A duplicate, dangling or cyclic reference can hide a segment behind another, place it where a viewer never draws it or stall a viewer that follows the chain.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
attachment-level-cyclicgw-9F8HQBEDetect a cycle in the display/attachment-level graph (a segment chain that attaches back onto itself)rejectreport omitspec; isg; gwfunctional
attachment-level-invalidgw-4VQ31EHDetect a non-zero attachment level (IALVL, SALVL, TXTALVL) that does not reference a valid display level (IDLVL or SDLVL)replacereplace report omitspec; isg; gwfunctional
display-level-not-uniquegw-D2GJW1ADetect duplicate display levels (IDLVL, SDLVL) across the filereplacereplace report omitspec; isg; gwfunctional

segment-information​

The segment information table defines the structure of the entire NITF file. Manipulated segment counts or lengths can hide data, cause buffer overflows or trick parsers into reading incorrect regions. Validating these values is critical for file integrity.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
des-count-out-of-rangegw-P6MXYZHDetect a number of DES segments (NUMDES) outside the range 0-999rejectreport omitspec; isg; gwfunctional
graphic-segment-count-out-of-rangegw-H2Z4P6BDetect a number of graphic segments (NUMS) outside the range 0-999rejectreport omitspec; isg; gwfunctional
image-segment-count-out-of-rangegw-VVM4X5MDetect a number of image segments (NUMI) outside the range 0-999rejectreport omitspec; isg; gwfunctional
label-segment-count-out-of-rangegw-PJ18YHJDetect a reserved segment count (NUMX) that is not 0rejectreport replace omitspec; isg; gwfunctional
res-count-out-of-rangegw-ZB2NZSHDetect a number of RES segments (NUMRES) outside the range 0-999rejectreport omitspec; isg; gwfunctional
res-count-unsupportedgw-3PRW7T5Detect NUMRES not equal to 000—Reserved Extension Segments are precluded per JBP 2024.1rejectreport omitspec; isg; gwfunctional
segment-alignment-invalidgw-QVD8RQ8Detect a segment whose subheader + data length does not align with the next segment startrejectreport omitspec; isg; gwfunctional
segment-length-out-of-rangegw-7RA51QBDetect segment subheader or data lengths outside the allowed rangesrejectreport omitspec; isg; gwfunctional
segment-location-invalidgw-KV5CQ80Detect a segment that does not exist at the correct file offset with the expected file part typerejectreport omitspec; isg; gwfunctional
segment-pair-count-invalidgw-924XPR7Detect segment length pair counts that do not match the declared segment countsrejectreport omitspec; isg; gwfunctional
segment-table-unreconciledgw-4CMRV84Detect a segment length table that does not reconcile with the declared file length (FL)rejectreport omitspec; isg; gwfunctional
text-segment-count-out-of-rangegw-CYYH9HBDetect a number of text segments (NUMT) outside the range 0-999rejectreport omitspec; isg; gwfunctional

tagged-record-extension-fields​

A value crafted inside an allowlisted TRE (out-of-range coefficient, NaN, non-enumerated code or an encoding-armored / injected byte) can ride through the structural TRE checks. Per-field schema validation of the high-value cataloged TREs detects poisoned values and neutralizes them in place where a safe default exists.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
geolob-field-valuesgw-DNASAXBDetect an out-of-range or malformed geo coordinate value inside a GEOLOB TREreportreportspec; gwfunctional
geopsb-field-valuesgw-1JS23K1Detect a non-enumerated coordinate-system value inside a GEOPSB TREreplacereplace reportspec; gwfunctional
geopsb-text-charsetgw-D2PKCX5Detect a non-printable or injected byte inside a GEOPSB text TREreplacereplace reportspec; gwfunctional
histoa-field-valuesgw-3C7X2M9Detect an out-of-range numeric field value inside a HISTOA TREreplacereplace reportspec; gwfunctional
histoa-text-charsetgw-ECXMYREDetect a non-printable or injected byte inside a HISTOA text TREreplacereplace reportspec; gwfunctional
ichipb-field-valuesgw-1HFN5GMDetect an out-of-range, NaN or non-enumerated field value inside an ICHIPB TREreplacereplace reportspec; gwfunctional
piaimc-field-valuesgw-63D4KT0Detect an out-of-range numeric field value inside a PIAIMC TREreplacereplace reportspec; gwfunctional
piaimc-text-charsetgw-JFJZNXYDetect a non-printable or injected byte inside a PIAIMC text TREreplacereplace reportspec; gwfunctional
pixmta-text-charsetgw-1T9MJH6Detect a non-printable or injected byte inside a PIXMTA text TREreplacereplace reportspec; gwfunctional

tagged-record-extensions​

TRE tags must be printable BCS-A, lengths must be accurate and data must be within bounds across all TRE locations. TRE data may contain sensitive information not visible in standard metadata.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
character-run-excessivegw-2HB5DQBDetect a run of one repeated character long enough to stall a backtracking patternreportreport omitspec; isg; gwstructural
tre-aggregate-size-anomalousgw-FBMY2H5Detect total TRE data occupying an anomalous proportion of the file sizereportreport omitspec; isg; gwfunctional
tre-data-disclosuregw-KMVWYCCDetect TRE free-text data that may carry sensitive informationreportreport omitspec; isg; gwfunctional
tre-data-embedded-filegw-8BKEYSVDetect TRE data carrying an embedded file signature other than markuprejectreport omitspec; isg; gwfunctional
tre-data-embedded-markupgw-PF1DTARDetect TRE data carrying an embedded XML or HTML signaturereportreport omitisg; gwfunctional
tre-data-entropy-suspiciousgw-0W2B11QDetect TRE data with anomalously high entropy indicating hidden or encrypted contentreportreport omitspec; isg; gwfunctional
tre-data-null-paddinggw-T640VA3Detect TRE data carrying null padding that may conceal hidden contentreportreport omitspec; isg; gwfunctional
tre-data-printable-ratio-suspiciousgw-C8MGAZKDetect TRE data with an anomalous printable-character ratioreportreport omitspec; isg; gwfunctional
tre-length-inaccurategw-5DAB279Detect a TRE length (TREL) that is not a valid 5-digit length or whose data is not accessiblerejectreport omitspec; isg; gwfunctional
tre-overflow-chain-invalidgw-C4B0HH3Detect TRE_OVERFLOW DES segments whose TREs do not match their declared sourcerejectreport omitspec; isg; gwfunctional
tre-overflow-incoherentgw-8GF24ADDetect TRE_OVERFLOW DES DESOFLW/DESITEM that do not match the source segment overflow pointersrejectreport omitspec; isg; gwfunctional
tre-phantom-presentgw-AABN1H8Detect phantom TRE areas not accounted for by declared TRE lengthsrejectreport omitspec; isg; gwfunctional
tre-size-anomalousgw-E75FJ68Detect a TRE length (TREL) that is anomalously large for its tagreportreport omitspec; isg; gwfunctional
tre-tag-collision-setgw-8PECSVHDetect extension tags chosen to share a hash value, degrading a consumer's lookupreportreport omitspec; isg; gwstructural
tre-tag-duplicategw-5QJC8TSDetect duplicate TRE tags within a segmentrejectreport omitspec; isg; gwfunctional
tre-tag-format-invalidgw-ZQ4GZYEDetect a TRE tag (TRETAG) that is not 6 BCS-A printable characters in any TRE locationrejectreport omitspec; isg; gwfunctional
tre-tag-not-allowlistedgw-XM5SE2ZDetect TRE tags outside the allowlist of known-good CETAG valuesreportreport omitspec; isg; gwfunctional
tre-tag-unregisteredgw-77WEJXHDetect TREs whose CETAG values are not in the known-good catalog (STDI-0002, STDI-0006, NGA.STND.0044, MIL-PRF-89034, NSGPDD, BPJ2K01)reportreport omitspec; isg; gwfunctional

text-extended-data​

TXSHDL defines the size of extended subheader data in text segments. Values of 1 or 2 are invalid (must be 0 or 3-99999). Manipulated lengths can cause parsers to read incorrect data. TXSHD TRE data may contain sensitive information that requires external filtering.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
text-ext-header-disclosuregw-2QMW37EDetect text extended-subheader (TXSHD) TRE free-text content that may carry sensitive informationreportreport omitspec; isg; gwfunctional
text-ext-header-length-invalidgw-PEJB863Detect a text extended-subheader data length (TXSHDL) that is invalidrejectreport omitspec; isg; gwfunctional

text-format​

Invalid text format or mismatched character encoding may hide data or enable attacks.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
text-data-charset-invalidgw-5HHFX05Detect malformed, control or non-text bytes in TXTDATA inconsistent with the declared TXTFMT charsetrejectreport omitspec; isg; gwfunctional
text-data-charset-supersetgw-CHS7PB2Detect well-formed characters in TXTDATA outside the declared TXTFMT charset (e.g. UTF-8 text in a BCS/ECS segment)reportreport omitspec; isg; gwfunctional
text-format-invalidgw-91ADGNHDetect a text format (TXTFMT) other than the allowed values MTF, STA, UT1 or U8Srejectreport omitspec; isg; gwfunctional

text-subheader​

Text subheader fields may contain forged or hidden data. TE must be 'TE', TXTDT must be a valid datetime not after FDT. TXTITL may disclose sensitive identification information.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
text-datetime-cross-segment-invalidgw-9RV3DZ6Detect a text date/time (TXTDT) later than the file date/time (FDT)reportreport omitspec; isg; gwfunctional
text-datetime-invalidgw-DKSFKARDetect a text date/time (TXTDT) that is not a valid CCYYMMDDhhmmss datetime or all hyphensreplacereplace report omitspec; isg; gwfunctional
text-id-non-defaultgw-0BH7NP0Detect a text segment identifier (TEXTID) carrying a non-default or potentially sensitive valuereplacereplace report omitisg; gwvisual
text-partition-invalidgw-30Q5AB1Detect a text subheader file part type (TE) other than 'TE'reportreport omitspec; isg; gwfunctional
text-title-disclosuregw-R71BZDJDetect a text segment title (TXTITL) that may carry sensitive free textreplacereplace report omitisg; gwvisual
text-title-free-text-disclosuregw-ADBEXYTDetect text segment title (TXTITL) free-text content that may carry sensitive informationreportreport omitspec; isg; gwfunctional

user-defined-header​

The User Defined Header Data fields (UDHDL, UDHOFL, UDHD) allow TRE data in the file header. Invalid length values or overflow references to non-existent DES segments can hide data or cause incorrect parsing. User Defined Header Data (UDHD) may contain TRE data with sensitive or classified information that requires external filtering before release.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
user-header-length-out-of-rangegw-NQGGPB0Detect a user-defined header data length (UDHDL) that is neither 0 nor within 3-99999reportreport omitspec; isg; gwfunctional
user-header-overflow-invalidgw-2JWSKX0Detect a user-defined header overflow reference (UDHOFL) that does not reference a valid DES segmentreportreport omitspec; isg; gwfunctional
user-header-presentgw-KD9JWG8Detect user-defined header (UDHD) TRE data that may carry sensitive informationreportreport omitisg; gwfunctional