Skip to main content
Version: 2.22.0

NITF and NSIF embedded content rules

A NITF or NSIF file can carry JPEG, JPEG 2000, EMF, WMF, H.264 and H.265 content and SIDD data extension segments. Glasswall Genesis inspects each with the format's own rules, and you set the action for any of them in the extendedFormatSettings section of a content management policy under overrides.<format>, where the format is one of jpeg, jpeg2000, emf, wmf, h264, h265 or sidd. See Configuring NITF and NSIF protection for the section itself and the rules for the NITF structure.

These rules apply only to content inside a NITF or NSIF file. A standalone file of one of these formats is not processed by Genesis.

Each rule is listed with its name and ID, either of which can be used as a key under rules. 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.

JPEG (jpeg)​

app0-jfif-marker-segment​

A buffer overflow data attack may occur if 'JFIF' is a non-zero terminated string. Unknown versions may contain different or more data that is unprocessed by applications. The thumbnail data is uncompressed RGB data and must be exactly 3 * width * height bytes or data may be hidden.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
jfif-app0-segmentgw-2ASADSXDetect a JFIF APP0 marker segment present in the fileremoveremove report omitisg; gwvisual
jfif-density-unitsgw-AJNQQKZDetect a JFIF APP0 density unit that is not 0, 1 or 2reportreport replace omitspec; isg; gwstructural
jfif-identifier-null-terminatedgw-DCA7TQNDetect a JFIF APP0 identifier that is not a zero-terminated 'JFIF' stringreportreport replace omitspec; isg; gwstructural
jfif-thumbnail-data-sizegw-CM50D74Detect JFIF APP0 thumbnail data whose size is not exactly 3 * Xthumbnail * Ythumbnail bytesreportreport omitspec; isg; gwstructural
jfif-versiongw-P9PFBMNDetect a JFIF APP0 version other than 1.02reportreport omitspec; isg; gwstructural

app0-thumbnail-image​

The image of the file and the thumbnail are not required to be of the same image. Data disclosure or data hiding are risks if the encoded image and thumbnail image are different. The thumbnail may reveal content not visible in the main image, or may be a different image entirely, resulting in inadvertent data disclosure.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
jfif-thumbnailgw-V395XX2Detect an uncompressed thumbnail image embedded in the JFIF APP0 marker segmentremoveremove replace report omitisg; gwvisual

application-marker-segments​

Application developers can decide how to use an application marker segment. Any type of data may be placed in an application marker segment allowing for data hiding, data disclosure and data attack concerns.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
adobe-colour-transform-markergw-HQW0PNPDetect the Adobe APP14 color-transform marker on a four-component (CMYK/YCCK) image, where it is the sole color-space declarationreplacereplace remove report omitisg; gwvisual
all-application-markersgw-9R5YGRRDetect APP0-APP15 application marker segments that may carry arbitrary application-defined dataremoveremove report omitisg; gwfunctional
application-marker-contentgw-KDKSD11Detect identifiable data types within application marker segments (text strings, JFIF thumbnail images, Exif metadata) that require external filteringreportreport omitisg; gwfunctional
unapproved-application-markersgw-6PQEBBPDetect application marker segments that are not on the approved application marker segment listremoveremove report omitisg; gwfunctional

comment-marker-segments​

Any data may be stored in a COM marker segment. Data hiding is possible since arbitrary data can be purposefully placed in the comment marker segment. Comments may contain information not intended for distribution, resulting in inadvertent data disclosure.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
comment-markersgw-12TH0XNDetect COM (comment) marker segments that may carry arbitrary text, metadata or hidden contentremoveremove replace report omitisg; gwvisual

content-identity​

A foreign container mis-identified as JPEG by its extension (e.g. a DjVu named .jpg—the CVE-2021-22204 delivery vector) is forwarded unchanged by a fail-open passthrough, and different downstream consumers route it to different parsers (a parser-differential / identification-divergence smuggling channel). An identified-but-unsupported JPEG subformat left unrecognized would be unrouted, so a container would pass it through untouched (a CDR bypass), while attempting to remediate it as baseline T.81 would corrupt it. Refusing the mis-identified or unsupported file closes the divergence so validate and protect agree, and no non-JPEG—or undecodable JPEG variant—is delivered under a JPEG name.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
foreign-container-magicgw-AZCDPHBDetect a file presented as JPEG whose leading magic bytes identify a different, recognized container format, or that has no recoverable JPEG SOI (start-of-image) markerreject—cve; gwstructural
t851-arithmetic-extension-unsupportedgw-T851GAPDetect a file that opens with the ITU-T T.851 JPG file-identifier (FF C8 00 05 'ac2'), an arithmetic-coding extension Genesis cannot decoderejectreport omitspec; gwstructural

dependent-marker-segments​

The presence of a dependent marker segment without the marker segment which is depended upon, or with an out-of-spec conditioning / expansion value, may indicate data hiding or a corrupted JPEG image and steers decoders apart.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
dac-conditioning-validgw-DACB6X1Detect an arithmetic conditioning (DAC) segment whose Tc/Tb/Cs value-space is out of spec (Table B.6)rejectreport omitspec; isg; gwstructural
dependent-differential-frame-requires-dhpgw-HPDDJY6Detect a differential frame header present without a required DHP marker segmentrejectreport omitspec; isg; gwstructural
exp-expand-geometry-validgw-EXPB3X1Detect an EXP (expand reference components) segment whose length or Eh/Ev expansion nibble geometry is out of specrejectreport omitspec; isg; gwstructural
exp-requires-dhpgw-KJTS9J6Detect an EXP marker segment present without a required DHP marker segmentrejectreport omitspec; isg; gwstructural
rst-requires-drigw-M73DZRWDetect an RST marker segment present without a required DRI marker segmentrejectreport omitspec; isg; gwstructural
tem-requires-arithmetic-framegw-5T4XVWADetect a TEM marker segment present without a required arithmetic coding framerejectreport omitspec; isg; gwstructural

entropy-coded-image-data​

Known steganography tools manipulate the DCT coefficients by embedding information within the entropy coded image data. The most popular method is to use the least significant bits (LSBs) of the DCT coefficients. If a binary program were located within or completely replaced the entropy coded image data, attempting to process the image can be a data attack.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
dct-coefficient-lsb-steganographygw-SXBGNFHDetect potential steganography in the least significant bits (LSBs) of the DCT coefficientsreportreport replace omitisg; gwvisual
entropy-data-executable-scangw-18VPVCFDetect known executable signatures within entropy coded segmentsreportreport omitisg; gwstructural
entropy-data-recompressgw-MVE59CWDetect entropy coded image data that may conceal hidden data recoverable by decompression and lossy recompressionreportreport replace omitisg; gwvisual
entropy-stream-decodablegw-KWJMMG4Detect an entropy coded stream or Huffman tables that fail a full decode, indicating a malformed or inconsistent codestreamreportreport omitspec; isg; gwstructural

exif-app-marker​

Exif markers can add any kind of data that TIFF supports making it a high risk for data hiding. Since a processing application must use a TIFF parser to parse the contents, an attacker could use a vulnerability in the TIFF parser. The TIFF may also include a thumbnail. Exif metadata may contain camera details, geolocation data, timestamps and other information not intended for distribution, resulting in inadvertent data disclosure.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
exif-identifier-null-terminatedgw-56BJWZSDetect an Exif APP marker identifier that is not zero terminated with an additional zero byte of paddingreportreport omitspec; isg; gwstructural
exif-markergw-J0R5DWVDetect an Exif APP1 marker segment present in the fileremoveremove report omitisg; gwfunctional
jfif-exif-exclusivitygw-RFGTYGQDetect both a JFIF APP marker and an Exif APP marker present when only one is permittedreportreport omitspec; isg; gwstructural
single-exif-markergw-HX687SEDetect more than one Exif APP marker present in the filereportreport omitspec; isg; gwstructural

frame-header​

A malformed frame header (missing component parameters) may cause a JPEG decoder to crash or malicious code to run. If there are more lines in the decompressed image than the Number of lines parameter, viewers will truncate the image data, hiding additional image content from the user.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
extraneous-frame-linesgw-8RQE1ZFDetect extraneous bytes exceeding the Number of lines parameterremoveremove report omitisg; gwstructural
frame-component-countgw-C141K8GDetect a frame header Number of components parameter that disagrees with the count of component parameters presentrejectreport omitspec; isg; gwstructural
frame-deep-precisiongw-JQ7VK2MDetect a coding frame declaring a sample precision above 8 bits (12-bit or 16-bit deep precision)—the decoder-attack shape behind CVE-2023-2804 (12-bit h2v2 merged upsample). Genesis's managed 8-bit codec cannot normalize deep-precision samples, so such a file is otherwise forwarded unremediated; reject it rather than passing a live trigger to a downstream native decoder.rejectreport omitcve; gwstructural
frame-header-well-formedgw-FHCJBZNDetect a frame header (SOF) with an out-of-range sample precision, component sampling factor or quantization-table selector; a sampling-factor sum (Σ Hi×Vi) exceeding 10; or a quantization-table selector that resolves to no defined DQTrejectreport omitspec; gwstructural
frame-line-countgw-3E3NGX1Detect a frame header Number-of-lines (Y) = 0 with no DNL marker segment to define the image height, an undefined-height header decoders resolve divergentlyrejectreport omitspec; isg; gwstructural

frames​

An image with more than one frame may be at risk of data hiding. Non-differential frames are stand-alone images; if more than one non-differential frame is present, data hiding may exist as unseen images. Hierarchical images are not well supported in open source libraries or commercial tools. A frame encoded with a codec or subformat Genesis cannot fully decode and re-encode (arithmetic, lossless, high-precision, JPEG-LS or an abbreviated / frameless stream) would otherwise be copied through uninspected as an alternate-codec hidden-content channel.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
dhp-precedes-differential-framegw-JTZQCSADetect a first differential frame that is not preceded by a DHP marker segmentrejectreport omitspec; isg; gwstructural
differential-frame-requires-dhpgw-HJM58AJDetect differential frames present without a DHP marker segmentrejectreport omitspec; isg; gwstructural
hierarchical-imagegw-PD7MA5YDetect a hierarchical image, an uncommon structure that can be restructured into a baseline JFIF imagereplacereplace report omitisg; gwvisual
single-non-differential-framegw-NYG94BWDetect more than one non-differential frame in the imagerejectreport omitspec; isg; gwstructural
unsupported-codec-modegw-2K9XTR4Detect a JPEG codec or subformat Genesis cannot fully decode and re-encode (arithmetic coding SOF9/10/11/13/14/15, lossless SOF3/7/11/15, sample precision above 8 bits, JPEG-LS SOF55/LSE or an abbreviated / frameless stream) whose entropy codestream would otherwise be copied through uninspectedrejectreport omitspec; isg; gwstructural

icc-profile​

An ICC profile is an embedded object adhering to an independent data format. Its data disclosure, hiding and attack risks must be subjected to the same level of scrutiny as the JFIF file that contains it. The ICC profile may contain metadata revealing information about the color processing pipeline or device characteristics not intended for distribution.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
icc-profile-presentgw-QXZH1S2Detect an ICC profile embedded in an APP2 marker segmentremoveremove replace report omitisg; gwvisual
icc-profile-validgw-SE1YSAZDetect an ICC profile that does not conform to the ICC format specificationreportreport omitspec; isg; gwstructural

image-boundaries​

The length between SOI and EOI markers is unconstrained; extra bytes may exist between markers and marker segments allowing data hiding. Data after the EOI is typically ignored by decoders and represents hidden data.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
data-after-eoigw-EZVBV08Detect data present after the EOI markerremoveremove report omitisg; gwstructural
data-before-soigw-DZHDRQ7Detect data present before the SOI markerremoveremove report omitisg; gwstructural
eoi-lastgw-Y1R85SADetect a file whose final bytes are not the EOI markerreject—spec; isg; gwstructural
inter-marker-gapsgw-RMYCGBTDetect extra bytes in the inter-marker gaps of the JFIF structure that could conceal hidden data, including the 0xFF fill bytes T.81 B.1.1.2 permits before a markerremoveremoveisg; gwstructural
markers-adjacentgw-WK26XQEDetect a marker or marker segment between SOI and EOI that is not directly adjacent to another marker or marker segmentrejectreport omitspec; isg; gwstructural
single-soi-eoi-pairgw-MQS9694Detect more than one SOI marker or more than one EOI marker in the filereject—spec; isg; gwstructural
soi-firstgw-2YF03JJDetect a file whose first bytes are not the SOI markerreject—spec; isg; gwstructural

jfif-extension-marker-segment​

A buffer overflow data attack may occur if 'JFXX' is a non-zero terminated string. An unknown extension type would allow a block of data not processed by viewers, representing a data hiding risk.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
jfxx-extension-codegw-S1FVNV6Detect a JFXX extension code that is not one of 0x10 (JPEG thumbnail), 0x11 (1 byte/pixel) or 0x13 (3 bytes/pixel)reportreport omitspec; isg; gwstructural
jfxx-identifier-null-terminatedgw-P4ETZVGDetect a JFXX APP0 identifier that is not a zero-terminated 'JFXX' stringreportreport replace omitspec; isg; gwstructural
jfxx-segmentgw-BCPK0QFDetect a JFXX extension APP0 marker segment present in the fileremoveremove report omitisg; gwvisual
jfxx-unknown-extensiongw-C9D4GR1Detect a JFXX extension segment whose extension code is not of a known typeremoveremove report omitisg; gwvisual

jfif-extension-thumbnail-image​

The image of the file and the thumbnail are not required to be of the same image. Data hiding is a risk if the encoded image and thumbnail differ. There may be thumbnail data in both JFIF and JFXX markers and applications may use either or neither of them. The extension thumbnail may reveal content not visible in the main image, or may be a different image entirely, resulting in inadvertent data disclosure.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
jfxx-thumbnailgw-M379C48Detect a thumbnail image embedded in the JFXX extension APP0 marker segmentremoveremove replace report omitisg; gwvisual
jfxx-thumbnail-no-jfif-markersgw-QVJ4K2ADetect JFIF markers present within the JFXX extension thumbnail imagereportreport omitspec; isg; gwstructural

marker-segment-length​

If the length specified is an invalid value (less than two or past the EOI) processing this marker segment is vulnerable to a data attack, possibly redirecting the processing application to an arbitrary address in memory resulting in a system crash or buffer overflow.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
marker-segment-lengthgw-TF472H9Detect a marker segment length that is out of range or extends past the EOI markerrejectreport omitspec; isg; gwstructural

marker-values-and-order​

An invalid marker indicates that the image file is malformed or corrupted and may indicate a data attack by causing the processing application to hang or crash.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
marker-ordergw-CXQ98NFDetect JPEG markers appearing out of the spec-defined orderrejectreport omitspec; isg; gwstructural
stray-ff00-outside-segmentgw-GFWYRSYDetect the hexadecimal value 0xFF00 appearing outside a marker segment or an entropy-coded segmentrejectreport omitspec; isg; gwstructural
stray-ffff-outside-segmentgw-5B8BMATDetect the hexadecimal value 0xFFFF appearing outside a marker segmentrejectreport omitspec; isg; gwstructural

nxpowerlite-app-marker​

As with all APP markers there is potential for data hiding, data disclosure and data attack. The NXPowerLite APP marker currently only includes an integer; however, there is no guarantee that the software will not expand the field in the future.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
nxpl-identifier-null-terminatedgw-GX2FH62Detect an NXPL APP marker identifier that is not zero terminatedreportreport omitspec; isg; gwstructural
nxpl-lengthgw-PDYPBXGDetect an NXPL APP marker whose length is not 8reportreport omitspec; isg; gwstructural
nxpl-markergw-ZH4F77CDetect an NXPowerLite (NXPL) APP marker segment present in the fileremoveremove report omitisg; gwfunctional
nxpl-positiongw-TW0GRJMDetect an NXPL APP marker in an inappropriate position (before SOI, after EOI or as the first APP marker)reportreport omitspec; isg; gwstructural
single-nxpl-markergw-FNGPFXFDetect more than one NXPL APP marker present in the filereportreport omitspec; isg; gwstructural

reserved-marker-segments​

The presence of a reserved marker segment may indicate data hiding. Their structure has not been specified in ISO/IEC 10918-1 and they are reserved for future revisions.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
reserved-markersgw-5T26D9FDetect reserved marker segments (RES, JPG, JPGn) whose structure is unspecifiedremoveremove report omitisg; gwstructural

scan-header​

A malformed scan header that may cause a JPEG decoder to crash and malicious code to run is considered a data attack.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
scan-component-countgw-QGVMNKVDetect a scan header Number of components parameter that disagrees with the count of component parameters presentrejectreport omitspec; isg; gwstructural
scan-header-specgw-ZX68W7BDetect scan header (SOS) parameters that do not conform to the JPEG specificationrejectreport omitspec; isg; gwstructural
scan-header-well-formedgw-RQ86VQGDetect a scan header (SOS) with an out-of-range entropy-table selector or successive-approximation bit position; a component count (Ns) disagreeing with the frame's (Nf) for a single sequential scan; a component selector (Cs) or entropy-table selector (Td/Ta) that resolves to no defined frame component or Huffman tablerejectreport omitspec; isg; gwstructural

scans​

Progressive processed frames contain multiple scans. The decoder may skip low-resolution scans and only display the high-resolution image. The presence of multiple scans is a data hiding risk. Converting to baseline does not sufficiently mitigate the issue since the selected scan could contain hidden data.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
progressive-multi-scangw-G2NR75ADetect a progressive image with multiple scans that can be flattened to a single-scan baseline JFIF imagereplacereplace report omitisg; gwvisual
single-scangw-39E0PYXDetect an image containing more than one scanreportreport omitspec; isg; gwstructural

tables​

Tables defined in a DQT, DHT or DAC segment but never referenced by a SOF or SOS segment are a data hiding risk.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
huffman-table-well-formedgw-RWEBY34Detect a Huffman table (DHT) with an out-of-range table class or destination selector, or whose code lengths overflow its marker segmentrejectreport omitspec; isg; gwstructural
quantization-table-well-formedgw-757NHSYDetect a quantization table (DQT) with an out-of-range element precision or destination selector, or whose definition overflows its marker segmentrejectreport omitspec; isg; gwstructural
unreferenced-tablesgw-GYJ2B1CDetect table marker segments (DQT, DHT, DAC) that are never referenced by a SOF or SOS segmentremoveremove report omitisg; gwstructural

JPEG 2000 (jpeg2000)​

binary-filter-box​

Contents of transformed data cannot be determined without decompressing or decrypting, posing data hiding and attack risks.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
binary-filter-box-presentgw-1GVB1CKDetect a Binary Filter box present in the fileremoveremove report omitisg; gwstructural
binary-filter-undecodable-invalidgw-KPTW5DVDetect Binary Filter box data that cannot be successfully decompressed or decryptedreportreport omitspec; isg; gwstructural
binary-filter-uuid-invalidgw-QQDM1RKDetect a Binary Filter box whose UUID field is not one of the two specified values (GZIP or DES)reportreport omitspec; isg; gwstructural

box-general​

Self-reported box lengths enable data hiding and covert channels. Readers may ignore unknown boxes while retaining hidden data. Buffer overflow risk from unbounded lengths.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
box-identifier-invalidgw-65M3SWRDetect a box carrying an identifier that is not valid per the specification (Tables 5-2 and 5-3)rejectremove report omitspec; isg; gwstructural
box-length-exceeds-maximumgw-A6FBVQ3Detect a box, with no specification-defined length bound, whose length exceeds a predefined maximum length valuerejectremove report omitspec; isg; gwstructural
box-length-out-of-rangegw-BFV17FZDetect a box whose length violates the bounds the specification defines for its box type (e.g. Signature 12 bytes, Image Header 22 bytes, Capture Resolution 18 bytes, Default Display Resolution 18 bytes, Composition Options 17 bytes), including data extending beyond that boundrejectremove report omitspec; isg; gwstructural
box-ordering-invalidgw-CACTTGADetect boxes whose ordering violates the specification (Signature first, Filetype second, Reader Requirements third, JP2 Header before Codestream)rejectreport omitspec; isg; gwstructural
box-unapproved-identifier-invalidgw-D62Y0RXDetect a box carrying an identifier that is not on the approved list of box identifiersremoveremove report omitisg; gwstructural

byte-aligned-segments​

RBAS can hold arbitrary amounts of data (data hiding risk). Long sequence of BAS or overly extended RBAS could crash reader application (data attack risk).

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
bas-excess-invalidgw-CGFR80XDetect Byte Aligned Segments exceeding a predefined count thresholdremoveremove report omitisg; gwstructural
bas-field-format-invalidgw-EREHYB7Detect a Byte Aligned Segment whose data does not adhere to the format for its specific fieldreportreport omitspec; isg; gwstructural

data-entry-url-box​

Data hiding from post-null-termination data and buffer overflow risks from unbounded URL strings.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
url-box-not-in-uuid-infogw-ATQ29ADDetect a Data Entry URL box that is not contained within a UUID Info boxreportreport omitspec; isg; gwstructural
url-box-presentgw-4B0E6KSDetect a Data Entry URL box present in the fileremoveremove replace report omitisg; gwstructural
url-post-null-data-presentgw-K80BG5DDetect data following the null termination of the URL stringremoveremove report omitisg; gwstructural
url-string-exceeds-maximumgw-X6KD4GSDetect a Data Entry URL box URL string that is longer than a predefined lengthreportreport omitspec; isg; gwstructural
url-string-not-null-terminatedgw-2S3P2NHDetect a Data Entry URL box URL string that is not null-terminatedreportreport omitspec; isg; gwstructural

digital-signature-box​

Reader may not have key management support to validate signature. Data hiding risk from unvalidated signatures.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
digital-signature-box-presentgw-R8Q4C1YDetect a Digital Signature box present in the fileremoveremove report omitisg; gwstructural
digital-signature-invalidgw-XSGB37KDetect a Digital Signature box whose checksum or signature is invalid or whose payload has been modifiedreportreport omitspec; isg; gwstructural
digital-signature-unapproved-invalidgw-K5T8ETDDetect a Digital Signature box using a digital signature (rather than a checksum) that is not on the approved listreportreport omitspec; isg; gwstructural

filetype-box​

Self-reported length enables covert channels. The compatibility list data field has no bounded length, posing data hiding risks.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
filetype-brand-invalidgw-M3KXBDGDetect a Filetype box brand or compatibility list value outside the defined ISO-15444 set ('jp2\040', 'J2P0', 'J2P1')replacereplace report omitspec; isg; gwstructural

free-box​

Free boxes are ignored by readers and pose a data hiding risk. Their contents are never displayed or processed.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
free-box-presentgw-HGDQ479Detect Free boxes present in the fileremoveremove report omitisg; gwstructural

icc-profile​

Embedded ICC profile is an independent format that requires the same scrutiny for data hiding and attack risks as the JPEG 2000 file.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
icc-profile-nonconforminggw-QVSHRC2Detect an embedded ICC profile that does not conform to the ICC format specificationreportreport omitspec; isg; gwstructural
icc-profile-presentgw-7AMJF0MDetect an ICC (International Color Consortium) profile embedded in the Color Specification boxremoveremove replace report omitisg; gwstructural

image-data​

Hidden data may be appended past the EOC (End of Codestream) marker, or carried in the least significant bits of the image samples that the format specification ignores.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
data-after-eoc-presentgw-ZFEVFCZDetect data following the EOC (End of Codestream) markerremoveremove report omitspec; isg; gwstructural
image-data-presentgw-N969SNCDetect an image codestream whose sample data can carry an LSB-hidden payload (a capability, not proof of a payload); a lossy or structural re-encode destroys the channel—this is a generic disarm, not steganalysisreportreport replace omitisg; gwvisual

jpsec-tools​

Use of confidentiality tool makes validation impossible without decryption password. Authentication tool poses data attack via URI. Certificate data is an avenue for attack.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
jpsec-authentication-invalidgw-N1D5W00Detect a JPSEC Authentication Template (tool ID 2) whose data fails validation under the appropriate authentication methodreportreport omitspec; isg; gwstructural
jpsec-encrypted-data-invalidgw-CZ3XERDDetect a JPSEC Decryption Template (tool ID 1) indicating the data is encryptedrejectremove report omitspec; isg; gwstructural
jpsec-hash-mismatch-invalidgw-CEGREJPDetect a JPSEC tool (tool ID 3) whose recomputed hash does not match the stored hash for the specified datareportreport omitspec; isg; gwstructural

marker-segments​

Self-reported marker segment lengths enable data hiding. Array size values in marker segments may be manipulated to cause buffer overflows.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
marker-code-invalidgw-XTQNRJ5Detect a marker segment carrying a code that is not validreportreport omitspec; isg; gwstructural
marker-reserved-valuegw-ZJDFHXYDetect a marker segment body carrying a reserved-enumeration or out-of-range field that changes the decode and cannot be safely normalizedrejectreport omitspec; isg; gwstructural
marker-reserved-bitsgw-E8P8S5FDetect a marker segment body carrying reserved bits (a covert channel a conformant decoder ignores) that can be cleared in placereplacereport omitspec; isg; gwstructural
marker-outside-codestreamgw-WFM5TS9Detect a marker segment that lies outside the codestream datareportreport omitspec; isg; gwstructural
marker-trailing-data-invalidgw-DK50JWVDetect a reserved marker code or a marker segment carrying data beyond its specification-defined length boundremoveremove report omitisg; gwstructural
comment-marker-presentgw-3TMWET7Detect optional Comments (COM) marker segmentsremoveremove replace report omitisg; gwstructural
unmodelled-marker-presentgw-MK7Q2P4Detect a codestream marker the engine does not model (a Part-2/15/17, JP3D, JPWL or otherwise-unrecognized extension marker, including CAP and PRF) whose body is copied through unvalidatedreportremove omitisg; gwstructural
in-packet-delimiter-inconsistentgw-P9X4RT2Detect in-packet delimiter markers (SOP/EPH) inconsistent with the coding-style signaling or carrying a non-monotonic SOP sequence number (a covert channel)reportomitspec; isg; gwstructural

media-data-box​

When data is not JPEG 2000 codestream, risks are the same as that data format and cannot be determined by the JPEG 2000 parser.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
media-data-noncodestream-invalidgw-FAY8FQ6Detect Media Data box content that is not a valid codestream when the Fragment Table box specifies codestream datareportreport omitspec; isg; gwstructural
media-data-presentgw-8C8KQCJDetect a Media Data box present in the fileremoveremove report omitisg; gwstructural

mpeg7-binary-box​

Box may be ignored by readers that do not support Motion JPEG 2000, posing data hiding risk.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
mpeg7-box-presentgw-ZDV72YMDetect an MPEG-7 Binary box present in the fileremoveremove report omitisg; gwstructural

multiple-codestreams​

No programmatic way to verify which codestream was intended for display. Additional codestreams may contain hidden data.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
jp2-multiple-codestreams-invalidgw-2W3SXSADetect JP2-formatted data carrying more than one codestream boxremoveremove report omitspec; isg; gwstructural

multiple-jpx-codestreams​

Each codestream in a JPX file is susceptible to the same data hiding and attack risks as individual codestreams (JPEG2000:8 through JPEG2000:11). See Section 5.3 recommendations.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
jpx-per-codestream-risks-invalidgw-YX8FBFJDetect a JPX file whose individual codestreams carry the same single-codestream risks (image data integrity, codestream count, resolution levels and steganography)reportreport omitspec; isg; gwstructural

reader-requirements-box​

Variable length Vendor Features list containing UUIDs may not be validated by readers, posing data hiding risk.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
vendor-features-presentgw-XV2AJGZDetect Vendor Features information present in the Reader Requirements boxremoveremove report omitisg; gwstructural

resolution-levels​

Progressive resolution capability poses data disclosure risk. Sensitive data may be revealed at certain resolution levels that are not visible at the default display resolution.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
decomposition-levels-invalidgw-F5CBETGDetect a codestream declaring more decomposition levels than the re-encode target, so higher-resolution detail can be removed or degraded by re-encodingreportreport replace omitspec; isg; gwvisual

signature-box​

Invalid signature values indicate non-valid JP2-formatted data. The Signature box is a fixed 12-byte box that must appear first.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
signature-error-check-invalidgw-70YG6V7Detect a Signature box whose error-check field is not 0x0D0A870A (not applicable when data is JPC formatted)rejectreport omitspec; isg; gwstructural

uuid-box​

The UUID box data field has no bounds or format defined by the specification, posing data hiding and buffer overflow risks.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
uuid-box-presentgw-F3XESNTDetect a UUID box present in the file (its unbounded, format-undefined data field poses a data-hiding risk)removeremove report omitisg; gwstructural

xml-extended-metadata-box​

XML schemas are loose and support input flexibility, posing data hiding and attack risks from malformed or oversized XML.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
xml-box-presentgw-N76PVYRDetect XML boxes present in the fileremoveremove report omitisg; gwstructural
xml-box-schema-invalidgw-G9YJBG1Detect XML extended metadata box data that does not validate against its corresponding schemareportreport replace omitspec; isg; gwstructural

EMF (emf)​

bitmap-records​

Bitmap records embed DIB (Device Independent Bitmap) data with offsets and sizes that must be validated against the record boundary. Invalid BITMAPINFOHEADER fields (biWidth, biHeight, biBitCount, biSizeImage) can cause heap overflows. Unknown biCompression values may trigger codec vulnerabilities. Source rectangles outside the bitmap dimensions cause out-of-bounds reads. MaskBlt and PlgBlt records have additional bitmap payloads that multiply the attack surface. Embedded JPEG/PNG data must be passed to the appropriate sub-camera.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
bitmap-records-boundsgw-YXAJ91ADetect bitmap record offsets or sizes that fall outside boundsreportreport omitspec; gwstructural
bitmap-records-compression-valuegw-QR9PQCVDetect a biCompression value outside the known set (BI_RGB, BI_RLE8, BI_RLE4, BI_BITFIELDS, BI_JPEG, BI_PNG)reportreport omitspec; gwstructural
bitmap-records-dib-header-sizegw-WRQVVJSDetect a DIB header size outside the known set (40 for BITMAPINFOHEADER, 108 for V4, 124 for V5)reportreport omitspec; gwstructural
bitmap-records-embedded-image-presentgw-JCNECCSDetect embedded raster image data (DIB, JPEG or PNG) carried in a bitmap recordreportreport omitgwstructural

clipping-records​

Clipping records define regions that restrict rendering output. Invalid rectangle coordinates can cause integer overflow in region calculations. EMR_EXTSELECTCLIPRGN contains variable-length region data whose size must match the record. Unknown region mode values cause undefined clipping behavior.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
clipping-records-combine-mode-valuesgw-HHZ0PHXDetect a region combining mode outside the known set (RGN_AND=1, RGN_OR=2, RGN_XOR=3, RGN_DIFF=4, RGN_COPY=5)reportreport omitspec; gwstructural
clipping-records-region-size-overflowgw-1D0K8BBDetect a region data size that exceeds the record boundaryrejectreport omitspec; gwstructural

color-management​

Color management records can embed ICC profiles (large binary blobs with known parser vulnerabilities), reference external profile file paths (path traversal attacks) and configure ICM processing modes. Profile paths may disclose file system layout. ICC profile data must be size-validated and passed to a specialized handler. Color match to target can reference external files.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
color-management-color-match-targetgw-4GQGWZ2Detect EMR_COLORMATCHTOTARGET records that reference external target profilesremoveremove report omitgwfunctional
color-management-external-pathsgw-DXVQX5QDetect external ICC profile file path referencesrejectreport omitspec; gwfunctional
color-management-icc-data-embeddedgw-62FG7VCDetect embedded ICC profile data that requires content validation by an external ICC profile handlerreportreport omitgwstructural
color-management-icc-size-overflowgw-TADPC50Detect an embedded ICC profile size that exceeds the record boundaryrejectreport omitspec; gwstructural
color-management-icm-modegw-THDC56VDetect an ICM mode enabling color management processingreplacereplace report omitgwfunctional
color-management-logcolorspace-valuesgw-NETK0ZRDetect a LOGCOLORSPACE colorspace type or intent outside the known setreportreport omitspec; gwstructural
color-management-profile-pathsgw-E2W6WWTDetect file path references in EMR_SETICMPROFILEA and EMR_SETICMPROFILEW recordsremoveremove report omitgwfunctional
color-management-structuregw-RF27NV8Detect color management records whose structure is malformedreportreport omitspec; gwstructural

comment-records​

EMF comment records are the primary vector for embedded content and data hiding. EMR_COMMENT_EMFPLUS embeds GDI+ instructions that constitute a second instruction stream. EMR_COMMENT_EMFSPOOL contains printer spool commands that may run with elevated privileges. Generic comments can hide arbitrary data. EMR_COMMENT_MULTIFORMATS can embed WMF, EMF or other format data. Unbalanced EMF+ groups cause resource leaks. The data size field must be validated against the record boundary.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
comment-records-data-size-within-recordgw-PB0BVMGDetect a comment data size (cbData) that is inconsistent with the record size (nSize - 12)reportreport omitspec; gwstructural
comment-records-embedded-content-presentgw-NCPARA4Detect embedded EMF+ or WMF content carried in a comment recordreportreport omitgwfunctional
comment-records-emfplus-nested-sizesgw-W6VWJPNDetect EMF+ record sizes within comment data that are inconsistent or exceed the comment boundaryreportreport omitspec; gwstructural
comment-records-emfspoolgw-8KYVF1FDetect EMR_COMMENT_EMFSPOOL records carrying printer spool commandsremoveremove report omitgwfunctional
comment-records-genericgw-WP5DZF8Detect generic EMR_COMMENT records that match no known public comment identifierremoveremove report omitgwfunctional
comment-records-group-bracket-balancegw-VVCJZNSDetect unbalanced GDICOMMENT_BEGINGROUP and GDICOMMENT_ENDGROUP recordsreportreport omitspec; gwstructural
comment-records-group-descriptiongw-5C7X3ZEDetect a GDICOMMENT_BEGINGROUP description string carrying arbitrary contentreplacereplace report omitgwvisual
comment-records-group-unicodegw-8TCM8EXDetect Unicode string data in a GDICOMMENT_BEGINGROUP descriptionremoveremove report omitgwvisual
comment-records-public-identifier-valuesgw-FTHVS7ZDetect an EMR_COMMENT_PUBLIC identifier outside the known set (GDICOMMENT_BEGINGROUP, GDICOMMENT_ENDGROUP, GDICOMMENT_MULTIFORMATS, GDICOMMENT_WINDOWS_METAFILE, GDICOMMENT_IDENTIFIER)reportreport omitspec; gwstructural
comment-records-structuregw-6N43FB8Detect comment records whose structure or content bounds are malformedreportreport omitspec; gwstructural
comment-records-unknown-identifiersgw-PE12CQXDetect comment records with unknown identifiersrejectreport omitspec; gwstructural

control-records​

EMR_EOF marks the end of the metafile. Missing EOF records cause parsers to read beyond valid data. Multiple EOF records can hide content between them. The SizeLast field enables reverse traversal; an incorrect value can mislead backwards-walking parsers. Palette data in the EOF record must be validated.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
control-records-eof-validationgw-WVPY6JVDetect a missing EMR_EOF record at the end of the filereportreport omitspec; gwstructural
control-records-single-eofgw-AATWFC6Detect more than one EMR_EOF recordrejectreport omitspec; gwstructural
control-records-sizelastgw-WWT4G6GDetect a SizeLast field that no longer matches the EMR_EOF record nSize after remediationreplacereplace report omitgwstructural

dc-save-restore​

EMR_SAVEDC pushes device context state onto a stack; EMR_RESTOREDC pops it. Unbalanced operations cause stack underflow (crash) or resource exhaustion (DoS via deep stack). The nRelSaveDC parameter in RestoreDC specifies how many levels to pop; negative values relative to current depth must be validated.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
dc-save-restore-stack-underflowgw-ND0EVT5Detect an EMR_RESTOREDC that would underflow the device context stackrejectreport omitspec; gwstructural

drawing-records​

Drawing records contain variable-length point arrays. Integer overflow in point count multiplication (count * sizeof(POINT)) can cause heap buffer overflows. PolyPolygon records have nested counts that must sum correctly. Extreme coordinate values can trigger integer overflow in rendering pipelines. Unknown vertex types in PolyDraw records cause undefined behavior.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
drawing-records-point-count-consistencygw-TGMWVPPDetect point counts in polygon/polyline records that are inconsistent with the record sizereportreport omitspec; gwstructural
drawing-records-point-count-maximumgw-A2PCC19Detect point counts that exceed a safe maximum for memory allocationrejectreport omitspec; gwstructural
drawing-records-point-countsgw-GNAA5P4Detect malformed point array counts in drawing recordsreportreport omitspec; gwstructural
drawing-records-polydraw-vertex-typesgw-9BRNJM6Detect PolyDraw vertex type bytes outside the known set (PT_LINETO, PT_BEZIERTO, PT_MOVETO, PT_CLOSEFIGURE)rejectreport omitspec; gwstructural

emf-header​

The EMR_HEADER defines the entire metafile's coordinate space, object table size and embedded description. Malformed signatures bypass format detection. Invalid bounds or frame rectangles can cause integer overflows in rendering. Zero device dimensions cause division-by-zero in coordinate transforms. The description string offset/length may read beyond the record. Reserved fields may hide data.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
emf-header-boundsgw-ZMY4P8VDetect an inconsistent EMF header bounding boxrejectreport omitspec; gwstructural
emf-header-description-boundsgw-ZN2R964Detect an EMF header description string that falls outside its boundsreportreport omitspec; gwvisual
emf-header-handle-count-nonzerogw-9CA8C3KDetect a handle count that is zero or outside a reasonable rangereportreport omitspec; gwstructural
emf-header-record-countgw-1J3YAHXDetect an EMF header record count that does not match the actual record countreportreport omitspec; gwstructural
emf-header-record-count-nonzerogw-63W1NDGDetect a declared record count that is zero or exceeds file size divided by minimum record sizereportreport omitspec; gwstructural
emf-header-record-typegw-4YJ7BWGDetect a first record type that is not EMR_HEADER (0x00000001)reportreport omitspec; gwstructural
emf-header-rectangles-validgw-AM0QY5KDetect a degenerate header bounding box or frame rectangle (right<left or bottom<top, excluding the empty-rectangle sentinel)reportreport omitspec; gwstructural
emf-header-reserved-fieldgw-C2J4RW1Detect a non-zero reserved field in the EMR_HEADERreplacereplace report omitgwstructural
emf-header-signaturegw-PRSC5J8Detect an EMF header signature that is not the expected valuerejectreport omitspec; gwstructural
emf-header-sizegw-CW9XYNGDetect an inconsistent EMF header record sizereportreport omitspec; gwstructural
emf-header-size-rangegw-HWM3GTTDetect a header record size (nSize) below 88 bytes or exceeding nBytesreportreport omitspec; gwstructural
emf-header-versiongw-AC0XHXMDetect an EMF header version that is not 0x00010000rejectreport omitspec; gwstructural

emfplus-records​

EMF+ records embed a second, parallel instruction stream inside EMR_COMMENT_EMFPLUS envelopes. Individual record types carry inner-field lengths (StringLength, Count, SubregionCount) whose declared value can exceed the record DataSize, producing the same 'header smaller than payload' memory-corruption shape as the outer EMF layer. Windows GDI+ has been exploited through EmfPlusDrawString string-length corruption (CVE-2021-1665), EmfPlusFillRects / EmfPlusSetTSClip rectangle-count mismatch (CVE-2025-30388) and EmfPlusDrawRects bitmap-scan overflow (CVE-2025-53766). EmfPlusComment records (MS-EMFPLUS §2.3.2.1) are the main place a steganography tool can hide a payload, as proof-of-concept tooling has shown. The record-structure rules catch gross boundary violations in the outer EMF record headers; the four bounds rules below check the inner fields of individual EMF+ records, and emfplus-records-comment-present flags EmfPlusComment payloads that remain when the operator has turned off their removal.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
emfplus-records-comment-presentgw-T8GNHA9Detect an EmfPlusComment record (type 0x4003) with non-empty Data, a location for arbitrary operator-defined steganography payload bytesreportreport omitspec; gwfunctional
emfplus-records-drawrects-boundsgw-XPHRC8YDetect an EmfPlusDrawRects record (type 0x400B) where Count * 16 + 8 exceeds DataSize, an undersized RectData array relative to the declared Countrejectreport omitspec; cve; gwstructural
emfplus-records-drawstring-boundsgw-3058EXVDetect an EmfPlusDrawString record (type 0x401C) where StringLength * 2 + 28 exceeds DataSize, a declared string length beyond the available payloadrejectreport omitspec; cve; gwstructural
emfplus-records-fillrects-boundsgw-HJ83H5CDetect an EmfPlusFillRects record (type 0x400A) where Count * 16 + 8 exceeds DataSize, an undersized RectData array relative to the declared Countrejectreport omitspec; cve; gwstructural
emfplus-records-settsclip-boundsgw-5KTMHVMDetect an EmfPlusSetTSClip record (type 0x403A) where the Count field (Flags low 13 bits) times the per-rectangle size (16 bytes, or 8 when Flags bit 15 is set) exceeds DataSizerejectreport omitspec; cve; gwstructural
emfplus-records-stream-embeddedgw-AXAVXKCDetect a preserved EMF+ record stream that requires downstream semantic validationreportreport omitgwfunctional

escape-records​

Escape records pass arbitrary data directly to device drivers, bypassing GDI rendering. EMR_DRAWESCAPE and EMR_EXTESCAPE can inject PostScript commands (CVE-style attacks). Named escapes reference driver-specific features. These records are the most dangerous attack vector in EMF files and should be removed or rejected in high-security environments.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
escape-records-datagw-VY6C67XDetect escape data payload carried in escape recordsremoveremove report omitgwfunctional
escape-records-data-size-within-recordgw-80W79RCDetect an escape data size that is inconsistent with the record sizereportreport omitspec; gwstructural
escape-records-drawgw-VCN7T7DDetect EMR_DRAWESCAPE recordsremoveremove report omitcve; gwfunctional
escape-records-extgw-5PWVXBYDetect EMR_EXTESCAPE recordsremoveremove report omitgwfunctional
escape-records-function-code-valuesgw-CMC46PDDetect an escape function code (iEscape) outside the known setreportreport omitspec; gwfunctional
escape-records-namedgw-9TM3WJ2Detect EMR_NAMEDESCAPE recordsremoveremove report omitgwfunctional
escape-records-postscriptgw-BMNWEYZDetect PostScript escape codes (POSTSCRIPT_DATA, POSTSCRIPT_PASSTHROUGH, ENCAPSULATED_POSTSCRIPT)rejectreport omitgwfunctional
escape-records-record-countgw-V043DJZDetect a header record count that no longer matches the record chain after escape record removalreplacereplace report omitgwstructural
escape-records-structuregw-N3D55AHDetect escape records whose structure is malformedreportreport omitspec; gwfunctional

file-structure​

Malformed file sizes can trigger buffer overflows or out-of-bounds reads in parsers. Oversized declarations may cause excessive memory allocation (DoS). Files smaller than the minimum EMF header size cannot be valid. Bytes after the EMR_EOF record are not rendered and are an ideal location for data hiding (embedded executables, steganographic content or an alternate appended file format).

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
file-structure-declared-exceeds-actualgw-MKDTPMYDetect a declared size that exceeds the actual file size, indicating a truncated or corrupted filerejectreport omitspec; gwstructural
file-structure-declared-sizegw-BYQCP09Detect a declared file size (nBytes in EMR_HEADER) that does not match the actual file sizereportreport omitspec; gwstructural
file-structure-integritygw-60ADQXPDetect a malformed EMF file structure across the record chain, sizes and offsetsrejectreport omitspec; gwstructural
file-structure-minimum-sizegw-X1K4DH4Detect an actual file size below the minimum EMF size (88 bytes for the header record)rejectreport omitspec; gwstructural
trailing-datagw-XG1XNQTDetect bytes following the EMR_EOF recordremoveremove report omitgwstructural

font-embedding​

Font embedding records reference Universal Font Identifiers (UFIs) and design vectors for font matching. Variable-length UFI arrays and design vector data can overflow record boundaries. Linked UFIs reference external font resources. Force UFI mapping can bypass normal font substitution, potentially loading malicious fonts.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
font-embedding-force-ufi-mappinggw-0EWSQ6WDetect EMR_FORCEUFIMAPPING records that bypass normal font substitutionremoveremove report omitgwfunctional
font-embedding-linked-ufisgw-WA2R2VJDetect linked UFI references that point to external font resourcesremoveremove report omitgwfunctional
font-embedding-size-overflowgw-GFEE1CYDetect a UFI count or design vector data that exceeds the record boundaryrejectreport omitspec; gwstructural
font-embedding-structuregw-M76MQHXDetect font embedding records whose structure is malformedreportreport omitspec; gwfunctional

object-creation​

EMF maintains an object handle table sized by nHandles in the header. Out-of-range handle indices cause array overflows. Selecting or deleting unoccupied handles indicates corruption or attack. Extended pen styles with custom dash patterns have variable-length arrays. Font face names can contain path traversal or null-injection attacks. Brush styles may reference embedded DIB data.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
object-creation-boundsgw-HACAJSCDetect object creation record offsets, sizes or handle limits that fall outside boundsreportreport omitspec; gwstructural
object-creation-brush-style-valuesgw-2ZSJTYNDetect a brush style value outside the known set (BS_SOLID, BS_NULL, BS_HATCHED, BS_PATTERN, BS_DIBPATTERN, BS_DIBPATTERNPT)reportreport omitspec; gwstructural
object-creation-handle-occupiedgw-G47ZJGDDetect an EMR_SELECTOBJECT that references an empty handle slot that is not a stock objectreportreport omitspec; gwstructural
object-creation-index-rangegw-2F2KDKSDetect an object handle index outside the range [0, nHandles-1]rejectreport omitspec; gwstructural
object-creation-pen-style-entry-countgw-7A44FQQDetect a custom dash pattern entry that is zero or an array count that is inconsistent with the record sizereportreport omitspec; gwstructural
object-creation-pen-style-valuesgw-QMFQ354Detect a pen style value outside the known set (PS_SOLID, PS_DASH, PS_DOT, PS_DASHDOT, PS_DASHDOTDOT, PS_NULL, PS_INSIDEFRAME, PS_USERSTYLE, PS_ALTERNATE)reportreport omitspec; gwstructural

opengl-records​

OpenGL records embed GLS (Graphics Library Stream) command data that is passed directly to the OpenGL driver. These records can run arbitrary GPU commands and are extremely dangerous. The bOpenGL flag in the header extension indicates OpenGL content presence. GLS data sizes must be validated. These records should be removed in security-conscious environments.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
opengl-recordsgw-NZQ93Z5Detect EMR_GLSRECORD or EMR_GLSBOUNDEDRECORD recordsrejectreport omitgwfunctional
opengl-records-bopenglgw-5AWYS9ZDetect a bOpenGL flag set in the EMR_HEADER extensionreplacereplace report omitgwfunctional
opengl-records-data-size-within-recordgw-807THD6Detect a GLS data size (cbData) that is inconsistent with the record sizereportreport omitspec; gwstructural
opengl-records-glsgw-EXQEG4HDetect EMR_GLSRECORD records carrying GLS command streamsremoveremove report omitgwfunctional
opengl-records-gls-boundedgw-D3HK0EVDetect EMR_GLSBOUNDEDRECORD records carrying bounded GLS data with rendering boundsremoveremove report omitgwfunctional
opengl-records-structuregw-1ZYS9DZDetect OpenGL records whose presence or structure is malformedreportreport omitspec; gwfunctional

palette-records​

Palette records contain variable-length entry arrays. Integer overflow in entry count multiplication can cause heap buffer overflows. The LOGPALETTE version must be 0x0300. Palette entry flags must be known values. ResizePalette can expand the palette beyond reasonable limits, causing excessive memory allocation.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
palette-records-entry-count-consistencygw-8Y2KA66Detect a palette entry count that is inconsistent with the record size (cEntries * 4 exceeds available data)reportreport omitspec; gwstructural
palette-records-resize-maximum-countgw-M4NKQSTDetect an EMR_RESIZEPALETTE entry count that exceeds the safe maximum (65536)reportreport omitspec; gwstructural
palette-records-structuregw-WAGHMK9Detect palette records whose structure is malformedreportreport omitspec; gwstructural
palette-records-version-and-flagsgw-TC0BVJ8Detect a LOGPALETTE version that is not 0x0300 or a palette entry flag outside the known set (0, PC_EXPLICIT, PC_NOCOLLAPSE, PC_RESERVED)reportreport omitspec; gwstructural

path-records​

Path brackets (BeginPath/EndPath) define GDI path construction regions. Unbalanced brackets can cause resource leaks or undefined state in renderers. Path control records (CloseFigure, FlattenPath, etc.) have fixed sizes; excess bytes may hide data.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
path-records-exact-sizegw-VEWNTD8Detect a path control record (BeginPath, EndPath, CloseFigure, FlattenPath, WidenPath, AbortPath) whose size is not the fixed 8 bytesreportreport omitspec; gwstructural
path-records-paddinggw-DZVCMJCDetect padding bytes beyond the expected 8-byte size in path control recordsreplacereplace report omitgwstructural

pixel-format​

Pixel format records configure OpenGL rendering surface properties. The PIXELFORMATDESCRIPTOR contains flags that enable hardware acceleration and overlay planes. Invalid nSize values can cause buffer overreads. These records are only meaningful for OpenGL-enabled metafiles and should be removed when OpenGL records are stripped.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
pixel-format-descriptor-exact-sizegw-MFJE1R1Detect a PIXELFORMATDESCRIPTOR nSize that is not the expected 40 bytesreportreport omitspec; gwstructural
pixel-format-descriptor-size-within-recordgw-KX60V7FDetect PIXELFORMATDESCRIPTOR data that does not fit within the record boundaryreportreport omitspec; gwstructural
pixel-format-flags-valuesgw-5HRH82XDetect pixel format flags, type or layer type outside the known setreportreport omitspec; gwfunctional
pixel-format-setpixelformatgw-JZASEABDetect EMR_SETPIXELFORMAT recordsremoveremove report omitgwfunctional
pixel-format-structuregw-6VSSRCADetect pixel format records whose structure is malformedreportreport omitspec; gwfunctional

post-cdr-validation​

Remediation may produce a structurally invalid EMF that fails to render.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
post-cdr-validation-round-tripgw-TVKJRGPDetect a post-CDR output file that does not re-parse as a valid EMF with EMR_HEADER first and EMR_EOF lastreportreport omitgwstructural

record-structure​

Each EMF record begins with a type and size. Undersized records cause buffer under-reads. Non-aligned sizes break sequential parsing. Mismatched record counts indicate hidden or missing records. Unknown record types may trigger undefined behavior in renderers. Cyclical size references can cause infinite loops.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
record-extends-beyond-filegw-NM70VFRDetect a record whose declared offset and size extend beyond the end of the filerejectreport omitspec; gwstructural
record-structure-alignmentgw-K24WEXRDetect a record size that is not DWORD-aligned (not a multiple of 4)reportreport omitspec; gwstructural
record-structure-minimum-sizegw-FK3PPSPDetect a record size below 8 bytes (the minimum for iType + nSize)reportreport omitspec; gwstructural
record-structure-minimum-size-per-typegw-89NZX53Detect a record smaller than the minimum size for its typerejectreport omitspec; gwstructural
record-structure-paddinggw-J6ACZYRDetect padding bytes within DWORD-aligned record sizesreplacereplace report omitgwstructural
record-structure-unknown-typesgw-99GKXR5Detect unknown or undefined record typesrejectreport omitspec; gwstructural
record-structure-validationgw-5EEYH6FDetect a malformed internal record structure (type, size, data alignment)rejectreport omitspec; gwstructural

state-records​

State records configure the device context rendering parameters. Invalid map mode values cause undefined coordinate transforms. Unknown enum values in SetBkMode, SetPolyFillMode, SetROP2, SetStretchBltMode and SetTextAlign can trigger undefined behavior. Records larger than the minimum required size may contain hidden data in padding bytes. Extreme miter limit values can cause rendering anomalies.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
state-records-enum-valuesgw-HR0G5QDDetect an enum value in SetBkMode, SetPolyFillMode, SetROP2, SetStretchBltMode or SetTextAlign outside the known setreportreport omitspec; gwstructural
state-records-exact-sizegw-PZYXTD7Detect a state record size that does not match the expected size for its record type (typically 12 bytes)reportreport omitspec; gwstructural
state-records-map-modegw-4E0NKHJDetect an unknown map mode or enum value in state recordsrejectreport omitspec; gwstructural
state-records-paddinggw-RKRRSXTDetect padding bytes in state records beyond their expected minimum sizereplacereplace report omitgwstructural

text-records​

Text records contain variable-length strings with offsets that must fall within the record boundary. The inter-character spacing (Dx) array size must match the character count. Integer overflow in offset + length calculations can cause out-of-bounds reads. SmallTextOut has a compact encoding with different validation requirements. Text content itself may contain sensitive information.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
text-records-char-count-consistencygw-BWGDKC2Detect a character count that is inconsistent with the available record data sizereportreport omitspec; gwstructural
text-records-content-embeddedgw-2SQ5ZPTDetect embedded text content that requires content inspection by an external text handlerreportreport omitgwvisual
text-records-options-flagsgw-GXK0HJVDetect text output option flags outside the known set (ETO_OPAQUE, ETO_CLIPPED, ETO_GLYPH_INDEX, ETO_RTLREADING, ETO_PDY)reportreport omitspec; gwstructural

transform-records​

World transform matrices control all coordinate mapping. NaN or Infinity values in matrix elements cause undefined rendering behavior and may crash renderers. A zero determinant (eM11*eM22 - eM12*eM21 = 0) makes the transform non-invertible, causing failures in hit-testing and reverse transforms. Zero extent transforms collapse all output to a single point.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
transform-records-nan-identitygw-QQYXVERDetect NaN or Infinity values in transform matrix elementsreportreport omitgwstructural

WMF (wmf)​

bitmap-records​

Bitmap records are the second-highest risk category in WMF. Buffer overflow exploits (CVE-2005-2123, CVE-2005-2124, CVE-2008-3015) exploit inconsistencies between record size and bitmap parameters. Integer overflow in size calculations can be triggered by negative or zero dimensions, or non-standard bit depths. Out-of-bounds reads occur when declared biSizeImage exceeds actual pixel data (CVE-2017-0190). Source-dependent raster operations with no embedded bitmap cause null pointer dereference.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
bitmap-dib-compressiongw-R6VDAQKDetect a biCompression value that is not a known DIB compression (BI_RGB=0, BI_RLE8=1, BI_RLE4=2, BI_BITFIELDS=3)reportreport omitspec; gwstructural
bitmap-dib-dimensionsgw-N3A66T9Detect DIB header fields outside valid ranges (biWidth <= 0, biHeight == 0 or biBitCount not in {1, 4, 8, 16, 24, 32})reportreport omitspec; gwstructural
bitmap-dib-size-imagegw-Y5F1SS5Detect a biSizeImage inconsistent with biWidth * biHeight * (biBitCount/8) accounting for row paddingreportreport omitspec; cve; gwstructural
bitmap-embedded-dibgw-EJ5EWPKDetect an embedded DIB bitmap that requires deep inspection by an image data handlerreportreport omitgwstructural
bitmap-raster-op-sourcegw-39XMF0YDetect a RasterOperation that references a source when no bitmap is present in the recordreportreport omitspec; gwstructural
bitmap-record-size-consistencygw-D9FPV4DDetect a RecordSize inconsistent with the declared bitmap dimensions, bit depth and compressionreportreport omitspec; gwstructural
bitmap-source-rect-boundsgw-WKFF2N4Detect source coordinates (XSrc, YSrc, SrcWidth, SrcHeight) that exceed the DIB dimensionsreportreport omitspec; gwstructural

device-context​

Zero extent values cause division by zero in coordinate transforms. Restoring a non-existent DC level causes stack underflow. Unknown mapping modes cause undefined coordinate transform behavior.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
dc-map-modegw-KRV7DSSDetect a META_SETMAPMODE with a mode that is not a known value from the MapMode enumerationreportreport omitspec; gwstructural
dc-save-restore-balancegw-6528Z1XDetect a META_RESTOREDC referencing a saved DC level that does not exist (unbalanced SAVEDC/RESTOREDC)reportreport omitspec; gwstructural
dc-viewport-extentgw-508AXG9Detect a META_SETVIEWPORTEXT with a zero width or heightreportreport omitspec; gwstructural
dc-window-extentgw-2MGDNWHDetect a META_SETWINDOWEXT with a zero width or heightreportreport omitspec; gwstructural

escape-records​

META_ESCAPE is the highest-risk record type in the WMF format. The infamous CVE-2005-4560 (SETABORTPROC) exploit used META_ESCAPE to achieve arbitrary code execution on all Windows versions. META_ESCAPE provides access to 50+ escape functions, many of which are printer-specific, capable of embedding arbitrary data or running arbitrary code. PostScript escapes inject arbitrary PostScript code. Passthrough escapes send raw data directly to the printer driver. Channel escapes open direct communication channels. MFCOMMENT embeds arbitrary binary data including full EMF files.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
escape-records-mfcommentgw-E6WSFDQDetect a META_ESCAPE record with EscapeFunction = MFCOMMENT (0x000F), which embeds arbitrary binary data as a comment (used to embed a full EMF file inside a WMF via META_ESCAPE_ENHANCED_METAFILE)removeremove report omitgwfunctional
escape-records-postscriptgw-VMFW9F7Detect a META_ESCAPE record with a PostScript EscapeFunction: POSTSCRIPT_DATA (0x0025), POSTSCRIPT_PASSTHROUGH (0x1013), POSTSCRIPT_IDENTIFY (0x1005), POSTSCRIPT_INJECTION (0x1006) or ENCAPSULATED_POSTSCRIPT (0x1014)rejectreport omitspec; gwfunctional
escape-records-presentgw-WPSAE8PDetect any META_ESCAPE recordremoveremove report omitgw; advisoryfunctional
escape-records-setabortprocgw-Q9WR00PDetect a META_ESCAPE record with EscapeFunction = SETABORTPROC (0x0009)rejectreport omitspec; cve; gwfunctional
escape-records-whitelistgw-9N259FVDetect a META_ESCAPE record whose escape function code is outside the approved whitelist (currently empty: there is no known safe subset of GDI escape functions for document processing, so all escape functions including PASSTHROUGH, SPCLPASSTHROUGH2, OPEN_CHANNEL, CLOSE_CHANNEL and DOWNLOAD_HEADER are detected)rejectreport omitspec; gwfunctional

font-records​

Unknown character sets may trigger undefined font mapper behavior. Non-terminated face names cause buffer over-read in font lookup. Extreme font dimensions can cause integer overflow in glyph rendering.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
font-char-setgw-F0MZST3Detect a CharSet that is not a known value from the CharacterSet enumerationreportreport omitspec; gwstructural
font-dimension-boundsgw-9M6P2TADetect lfHeight or lfWidth outside reasonable boundsreportreport omitspec; gwstructural
font-face-name-disclosuregw-WW5J3CMDetect a FaceName that may disclose sensitive informationreportreport omitspec; gwvisual
font-face-name-terminationgw-Q63APBEDetect a FaceName that is not null-terminated within 32 bytesreportreport omitspec; gwstructural

meta-header​

Data attack risks exist if the file type, version or size fields are malformed. Size mismatch is a common indicator of appended data or truncation; exploits often set invalid sizes to confuse parsers (CVE-2007-1211). Oversized object tables can trigger excessive memory allocation. The NumberOfMembers field is unused and non-zero values may hide data.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
meta-header-file-sizegw-8P5G6WEDetect SizeLow/SizeHigh (total file size in WORDs) that disagrees with the actual file lengthreportreport omitspec; gwstructural
meta-header-gap-datagw-5WXX0ARDetect data between the end of the placeable header (if present) and the start of META_HEADERreportreport omitspec; gwstructural
meta-header-invalid-typegw-WMFT8RJDetect a META_HEADER Type field that is not 0x0001 (memory) or 0x0002 (disk)rejectreport omitspec; gwstructural
meta-header-invalid-versiongw-WMFV9PKDetect a META_HEADER Version field that is not 0x0100 or 0x0300rejectreport omitspec; gwstructural
meta-header-max-recordgw-FNK26NKDetect a MaxRecord value that exceeds the file sizereportreport omitspec; gwstructural
meta-header-number-of-membersgw-Q06Z4KCDetect a non-zero NumberOfMembers field (unused per MS-WMF; non-zero values may hide data)replacereplace report omitgwstructural
meta-header-number-of-objectsgw-A0Q1W9ADetect a NumberOfObjects that is unreasonable (e.g., > 65535) or inconsistent with the actual object creation records in the streamreportreport omitspec; gwstructural

object-table​

Out-of-range object indices cause use of uninitialized memory or out-of-bounds table access. Double-free or deletion of non-existent objects causes heap corruption. Exceeding the object table causes heap overflow. Leaked objects may indicate incomplete record streams designed to exhaust resources.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
object-delete-index-validgw-VXVMFX2Detect a META_DELETEOBJECT index outside the range [0, NumberOfObjects) or referencing an unoccupied slotreportreport omitspec; gwstructural
object-lifecycle-completegw-PE3XQZVDetect created objects that are never deleted (leaked objects)reportreport omitspec; gwstructural
object-select-index-rangegw-9VHXCN6Detect a META_SELECTOBJECT index outside the range [0, NumberOfObjects)reportreport omitspec; gwstructural
object-table-overflowgw-X2N72YYDetect objects created beyond the declared NumberOfObjects limitreportreport omitspec; gwstructural

palette-records​

Mismatch between NumberOfEntries and RecordSize causes buffer overflow when reading palette entries. Unknown palette entry flags may trigger undefined behavior. Excessive palette sizes can exhaust memory.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
palette-entry-count-consistencygw-9Q8B8VRDetect a META_CREATEPALETTE whose NumberOfEntries is inconsistent with RecordSizereportreport omitspec; gwstructural
palette-entry-flagsgw-T7WN4CYDetect a palette entry PaletteEntryFlag value that is not a known flag (0x00, 0x01, 0x02, 0x04)reportreport omitspec; gwstructural
palette-resize-boundsgw-9YV4QXGDetect a META_RESIZEPALETTE whose new size exceeds 65536 entriesreportreport omitspec; gwstructural

placeable-header​

Data attack risks exist if the magic number is malformed, which may indicate format confusion attacks. Checksum mismatch indicates tampering or corruption. Inconsistent bounding box coordinates can trigger integer overflow in renderer dimension calculations. A zero resolution value causes division by zero in coordinate transforms. The reserved field must be zero; non-zero values may hide data.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
placeable-header-bounding-boxgw-DQ3FGNRDetect inconsistent BoundingBox coordinates (Left > Right or Top > Bottom)reportreport omitspec; gwstructural
placeable-header-checksumgw-V13JQNHDetect a checksum field (XOR of the first 10 WORDs) that disagrees with the computed valuereportreport omitspec; gwstructural
placeable-header-magicgw-FXBGZ9QDetect a placeable header magic number that is not 0x9AC6CDD7reportreport omitspec; gwstructural
placeable-header-reservedgw-EJKFWZWDetect a non-zero placeable header Reserved field (must be 0x00000000)replacereplace report omitgwstructural
placeable-header-zero-inchgw-MM7KR3QDetect a placeable header Inch (resolution) field of 0rejectreport omitspec; gwstructural

polygon-region-records​

Integer overflow in vertex count sums causes undersized buffer allocation followed by heap overflow (CVE-2006-2376, MS06-026). Mismatch between point counts and record size causes out-of-bounds read/write. Complex region data parsing has historically been vulnerable to buffer overflows. Extreme coordinates can cause integer overflow in rendering calculations.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
point-coordinate-boundsgw-1ET88JSDetect point coordinates outside the declared bounding box or window extentreportreport omitspec; gwstructural
polygon-point-count-consistencygw-K6HCSX1Detect a META_POLYGON/META_POLYLINE whose NumberOfPoints is inconsistent with RecordSizereportreport omitspec; gwstructural
polypolygon-vertex-overflowgw-XVM0SW7Detect a META_POLYPOLYGON where the sum of all polygon vertex counts overflows a 32-bit integerreportreport omitspec; cve; gwstructural
region-data-consistencygw-3WBPPQDDetect a META_CREATEREGION whose region data size is inconsistent with RecordSize or exceeds reasonable boundsreportreport omitspec; gwstructural

post-cdr-validation​

Remediation may produce a structurally invalid WMF that fails to render.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
post-cdr-round-tripgw-D1E30S6Detect a protected WMF output that fails post-CDR round-trip re-parse (missing header, missing EOF record or otherwise structurally invalid)reportreport omitgwstructural

record-chain​

Records smaller than 3 WORDs are malformed and may cause infinite loops or negative seeks. Records extending past EOF cause out-of-bounds reads. Missing EOF indicates truncation; multiple EOFs indicate appended data. Oscillating record sizes are a known DoS pattern causing 100% CPU consumption. Trailing data after META_EOF can hide arbitrary payloads. Unknown record types indicate corruption, future format extensions or deliberate obfuscation.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
record-chain-cumulative-sizegw-BGJT8TNDetect cumulative record sizes that exceed the file lengthreportreport omitspec; gwstructural
record-chain-eof-presentgw-QG0STSWDetect data present after the META_EOF recordremoveremove report omitgwstructural
record-chain-known-typesgw-JKR9HW8Detect a RecordFunction value that is not a known value from the RecordType enumerationreportreport omitspec; gwstructural
record-chain-minimum-sizegw-DC19TTBDetect a record whose RecordSize is less than 3 WORDs (minimum: size + type fields)reportreport omitspec; gwstructural
record-chain-oscillating-sizesgw-WGA0WR9Detect consecutive records whose sizes oscillate (e.g., +3/-3), a pattern that can create an infinite loopreportreport omitspec; gwstructural
record-chain-single-eofgw-CMGQH2DDetect a record chain that does not terminate with exactly one META_EOF recordreportreport omitspec; gwstructural
record-chain-trailing-datagw-TAGY5R3Detect trailing data after the META_EOF recordreportreport omitspec; gwstructural
record-chain-trailing-data-removegw-RPPAK3YDetect trailing data after the META_EOF record that can be removedremoveremove report omitgwstructural
record-chain-unknown-typesgw-05N7054Detect unknown/undocumented record typesreportreport omitspec; gwstructural
record-chain-unknown-types-rejectgw-XE80ADGDetect unknown or unrecognized record typesrejectreport omitspec; gwstructural

text-records​

String length exceeding available record data causes buffer over-read. Malformed clipping rectangles in META_EXTTEXTOUT can trigger integer overflow.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
text-clipping-rect-consistencygw-YY1K9DWDetect a META_EXTTEXTOUT with an inconsistent optional clipping rectanglereportreport omitspec; gwstructural
text-content-disclosuregw-T1VZ4RWDetect text content that may contain sensitive informationreportreport omitgwvisual
text-string-length-consistencygw-N98JZVCDetect a StringLength inconsistent with RecordSizereportreport omitspec; gwstructural

H.264 (h264)​

access-unit-delimiter​

AUD NAL units are structurally simple (1-byte payload); an oversized AUD could carry hidden data after the primary_pic_type field.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
aud-primary-pic-type-out-of-rangegw-AVFN14WDetect an AUD primary_pic_type outside the range 0-7reportreport omitspec; gwstructural
aud-size-oversizedgw-SYYT35NDetect an AUD NAL unit whose RBSP size exceeds the expected 1 byte (primary_pic_type + trailing bits)reportreport omitspec; gwstructural

emulation-prevention​

Incorrect emulation prevention byte handling causes parser differentials and heap overflows; CVE-2024-22860 demonstrated a heap buffer overflow during RBSP decoding when emulation prevention bytes were incorrectly counted.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
emulation-prevention-byte-misplacedgw-G5CCR9ZDetect an emulation prevention byte (0x03 after 0x0000) incorrectly placed per Annex Breportreport omitspec; cvestructural
emulation-prevention-invalidgw-46P0V6PDetect RBSP data containing 0x000000, 0x000001 or 0x000002 without proper emulation preventionreportreport omitspec; cvestructural

filler-data​

Filler data NAL units are defined as 0xFF padding bytes for CBR rate control; modified byte values can carry steganographic content that is invisible to video playback but extractable by a receiver.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
filler-data-content-invalidgw-RR9MRV1Detect a retained filler data NAL unit whose payload bytes are not all 0xFFreportreport omitspec; gwstructural
filler-nal-presentgw-VMERW3GDetect a filler data NAL unit (nal_unit_type 12)removeremove report omitisg; gwstructural

nal-header​

A set forbidden_zero_bit indicates a corrupt or crafted NAL unit; reserved and unspecified NAL unit types may be misinterpreted by different decoders (parser differential attacks) and can carry hidden data that no standard decoder processes; nal_ref_idc inconsistency with NAL type indicates structural corruption.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
forbidden-zero-bit-rejectgw-8HPWN2NDetect a NAL unit with forbidden_zero_bit set to 1rejectreport omitspec; isg; gwstructural
forbidden-zero-bit-setgw-K3PGXMZDetect a NAL unit whose forbidden_zero_bit is set to 1reportreport omitspec; isg; gwstructural
nal-ref-idc-nonzero-invalidgw-W01HTMSDetect a non-zero nal_ref_idc on a NAL unit of type 6 (SEI), 9 (AUD), 10 (EOS), 11 (EOB) or 12 (filler)reportreport omitspec; gwstructural
nal-ref-idc-zero-invalidgw-FBW21AFDetect a zero nal_ref_idc on a NAL unit of type 5 (IDR), 7 (SPS), 8 (PPS) or 15 (subset SPS)reportreport omitspec; gwstructural
nal-type-undefinedgw-GBVZ5RVDetect a nal_unit_type outside the range of defined types (1-12, 13-15, 19-21)reportreport omitspec; gwstructural
unspecified-nal-presentgw-43B38B1Detect an unspecified or reserved NAL unit (nal_unit_type 0, 22-23 or 24-31)removeremove report omitisg; gwstructural

pps-parameters​

PPS fields control reference picture list sizing for all slices that reference this PPS; crafted reference index override values cause heap overflow, and a PPS must reference a valid SPS.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
pps-id-out-of-rangegw-3D4Z9A2Detect a PPS pic_parameter_set_id outside the range 0-255rejectreport omitspec; gwstructural
pps-ref-idx-exceeds-spsgw-KR6Q75QDetect a PPS num_ref_idx default value exceeding max_num_ref_frames from the referenced SPSrejectreport omitspec; cve; gwstructural
pps-ref-idx-l0-out-of-rangegw-ZYGJSX6Detect a PPS num_ref_idx_l0_default_active_minus1 outside the range 0-31rejectreport omitspec; cve; gwstructural
pps-ref-idx-l1-out-of-rangegw-5JZDZSDDetect a PPS num_ref_idx_l1_default_active_minus1 outside the range 0-31rejectreport omitspec; cve; gwstructural
pps-sps-cross-reference-invalidgw-S058SQDDetect a PPS seq_parameter_set_id outside the range 0-31 or referencing no active SPSrejectreport omitspec; cve; gwstructural

sei-messages​

SEI payloadSize values exceeding the remaining NAL unit bytes trigger heap buffer overflows; user_data and filler SEI messages carry arbitrary payloads with no effect on decoded video and are the primary H.264 covert channels. Every other Annex D type carries attacker-chosen bytes a decoder does not read for reconstruction, so a type left unowned is a channel that no rule reports.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
sei-filler-payloadgw-1A104GKDetect a SEI message with payloadType 3 (filler_payload)removeremove report omitisg; gwstructural
sei-hdr-metadata-presentgw-2NSWEE9Detect a mastering_display_colour_volume (payloadType 137) or content_light_level_info (payloadType 144) HDR metadata SEI messagereportreport omitgwvisual
sei-non-essential-presentgw-0Z2GY6MDetect a SEI message of any Annex D payload type outside the named and retained setsremoveremove report omitisg; gwstructural
sei-payload-bounds-exceededgw-KY61VCZDetect a SEI NAL unit whose payloadSize exceeds the NAL unit boundsrejectreport omitspec; cvestructural
sei-payload-size-out-of-boundsgw-BVK66CADetect a SEI message whose payloadSize exceeds the remaining bytes in the NAL unit RBSPreportreport omitspec; cvestructural
sei-total-size-out-of-boundsgw-K3HQC38Detect total SEI message bytes exceeding the NAL unit sizereportreport omitspec; cvestructural
sei-unknown-typegw-XN7CVCKDetect a SEI message whose payloadType is not defined in ITU-T H.264 Annex Dremoveremove report omitisg; gwstructural
sei-user-data-registeredgw-2H0EDJ2Detect a SEI message with payloadType 4 (user_data_registered_itu_t_t35)removeremove report omitisg; gwfunctional
sei-user-data-unregisteredgw-JCHWPW5Detect a SEI message with payloadType 5 (user_data_unregistered)removeremove report omitisg; gwfunctional

slice-header​

Slice header fields reference PPS (which references SPS), creating a chain of dependent parameters; a crafted first_mb_in_slice exceeding frame dimensions causes out-of-bounds access, and crafted reference list reordering caused kernel RCE in Apple AVD.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
first-mb-out-of-rangegw-HYVERA1Detect a slice first_mb_in_slice outside the range 0 to (PicSizeInMbs - 1)reportreport omitspec; cvestructural
first-slice-not-idrgw-3K4WVWDDetect a first coded slice in the stream that is not an IDR slice (nal_unit_type 5)reportreport omitspec; gwstructural
frame-num-out-of-rangegw-4NVAHAYDetect a slice frame_num outside the range 0 to (MaxFrameNum - 1)reportreport omitspecstructural
idr-pic-id-out-of-rangegw-260ZKYZDetect an IDR slice idr_pic_id outside the range 0-65535reportreport omitspecstructural
slice-pps-id-invalidgw-BZBRFBMDetect a slice pic_parameter_set_id that references no active PPSreportreport omitspec; cvestructural
slice-type-out-of-rangegw-PP4FTQWDetect a slice slice_type outside the range 0-9reportreport omitspecstructural

sps-parameters​

Crafted SPS dimension values cause integer overflow in width*height multiplication, leading to small buffer allocation followed by large data writes; invalid profile/level, chroma, bit-depth and picture-order-count values trigger type confusion, incorrect buffer sizing, excessive allocation or infinite parsing loops in decoders.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
parameter-set-id-conflictgw-NTMJK2SDetect two sequence parameter sets that share a seq_parameter_set_id while coding different picturesremoveremove report omitspec; gwstructural
sps-bit-depth-chroma-out-of-rangegw-T9A6VRDDetect a SPS bit_depth_chroma_minus8 outside the range 0-6rejectreport omitspec; cve; gwstructural
sps-bit-depth-luma-out-of-rangegw-X97P7K2Detect a SPS bit_depth_luma_minus8 outside the range 0-6rejectreport omitspec; cve; gwstructural
sps-chroma-format-idc-out-of-rangegw-X3FZ7GDDetect a SPS chroma_format_idc outside the range 0-3rejectreport omitspec; cve; gwstructural
sps-frame-size-excessivegw-XXNGSJ8Detect a SPS whose computed frame size exceeds 8192x8192 or the level-defined MaxFSrejectreport omitspec; cve; gwstructural
sps-height-out-of-rangegw-MS67W3JDetect a SPS pic_height_in_map_units_minus1 that produces a frame height exceeding 8192 pixelsrejectreport omitspec; cve; gwstructural
sps-id-out-of-rangegw-7WA5J83Detect a SPS seq_parameter_set_id outside the range 0-31rejectreport omitspec; gwstructural
sps-level-idc-invalidgw-7WYJ9FJDetect a SPS level_idc that is not a recognized level valuereplacereplace report omitspec; gwstructural
sps-log2-max-frame-num-out-of-rangegw-E58FF7VDetect a SPS log2_max_frame_num_minus4 outside the range 0-12rejectreport omitspec; gwstructural
sps-log2-max-poc-lsb-out-of-rangegw-FVDEXJCDetect a SPS log2_max_pic_order_cnt_lsb_minus4 outside the range 0-12rejectreport omitspec; gwstructural
sps-max-ref-frames-out-of-rangegw-GTV864CDetect a SPS max_num_ref_frames outside the range 0-16rejectreport omitspec; cve; gwstructural
sps-num-ref-frames-poc-cycle-out-of-rangegw-66VC06CDetect a SPS num_ref_frames_in_pic_order_cnt_cycle outside the range 0-255rejectreport omitspec; cve; gwstructural
sps-poc-type-out-of-rangegw-XY5HQ47Detect a SPS pic_order_cnt_type outside the range 0-2rejectreport omitspec; cve; gwstructural
sps-profile-idc-invalidgw-BZV39BGDetect a SPS profile_idc that is not a recognized profile valuerejectreport omitspec; cve; gwstructural
sps-width-out-of-rangegw-XA4710MDetect a SPS pic_width_in_mbs_minus1 that produces a frame width exceeding 8192 pixelsrejectreport omitspec; cve; gwstructural

stream-structure​

Malformed start codes cause parser differentials between Genesis and downstream decoders, enabling NAL unit smuggling; missing parameter sets before coded slices crash decoders; non-zero trailing data after the last NAL unit may carry hidden payloads.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
content-after-end-of-streamgw-2FWMSS5Detect NAL units that follow the end_of_stream NAL unitremoveremove report omitspec; gwstructural
leading-gap-content-presentgw-0G4F6XADetect non-zero data before the first start code prefixremoveremove report omitspec; gwstructural
nal-unit-absentgw-EQ6N5A2Detect a byte stream containing no NAL unitsreportreport omitspec; gwstructural
pps-absentgw-PKKFG5XDetect no PPS (nal_unit_type 8) present before the first coded slicereportreport omitspec; gwstructural
pps-sps-reference-invalidgw-4ARH64QDetect a PPS whose seq_parameter_set_id references no prior SPSreportreport omitspec; gwstructural
slice-pps-reference-invalidgw-0H352A3Detect a coded slice whose pic_parameter_set_id references no prior PPSreportreport omitspec; gwstructural
sps-absentgw-CQJQ3XADetect no SPS (nal_unit_type 7) present before the first coded slicereportreport omitspec; gwstructural
start-code-invalidgw-MGY5RG5Detect a NAL unit not preceded by a valid start code prefix (0x000001 or 0x00000001)reportreport omitspec; gwstructural
stream-start-invalidgw-5ESKN84Detect a byte stream that does not begin with a start code prefix (leading non-zero data)reportreport omitspec; gwstructural
trailing-data-presentgw-QJ5262BDetect non-zero data present after the RBSP of the last NAL unitremoveremove report omitgwstructural

H.265 (h265)​

filler-data​

Filler data NAL units and SEI payloads contain bytes ignored by decoders. They serve no content purpose and are a data-hiding channel.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
filler-nal-presentgw-W7EC4JNDetect a filler-data NAL unit (type 38) or filler SEI payload (payloadType 3)removeremove report omitgwstructural

nal-header​

Malformed NAL headers cause parser state corruption. The forbidden_zero_bit indicates corruption, invalid types trigger undefined behavior, and a zero temporal_id causes decoder crashes.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
nal-forbidden-zero-bit-rejectgw-R87T8PNDetect a NAL unit with forbidden_zero_bit set to 1 that cannot be safely repairedrejectreport omitspec; cve; gwstructural
nal-layer-id-nonzerogw-DCYF873Detect a NAL unit with nuh_layer_id not equal to 0 in a single-layer streamreportreport omitspec; gwfunctional
nal-temporal-id-zerogw-SF2WE2RDetect a NAL unit with nuh_temporal_id_plus1 equal to 0 (forbidden)reportreport omitspec; gwfunctional
nal-type-out-of-rangegw-KR3C7QTDetect a NAL unit whose nal_unit_type is outside the 0-63 rangereportreport omitspec; gwstructural
param-set-temporal-id-invalidgw-DZ4K4SADetect a VPS/SPS/PPS NAL unit whose nuh_temporal_id_plus1 is not 1reportreport omitspec; gwfunctional

nal-ordering​

Parameter sets must precede the NAL units that reference them. Out-of-order NAL units cause parser differentials between Genesis and the decoder, enabling bypass attacks.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
aud-ordering-invalidgw-78RSSPBDetect an access-unit delimiter (type 35) not appearing first in its access unitreportreport omitspec; gwfunctional
pps-after-slicegw-59TX379Detect a PPS appearing after a slice that references itreportreport omitspec; gwfunctional
sps-after-ppsgw-6WVFPJWDetect an SPS appearing after a PPS that references itreportreport omitspec; gwfunctional
vps-after-spsgw-PYQ5CXKDetect a VPS appearing after an SPS that references itreportreport omitspec; gwfunctional

nal-type​

Reserved (10-15, 22-31, 41-47) and unspecified (48-63) NAL types carry no defined semantics and are data-hiding vectors; parsers handle them inconsistently, creating differential vulnerabilities. VCL NAL units that reference a missing PPS crash decoders.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
nal-type-defined-range-invalidgw-2JY7HG7Detect a NAL unit whose nal_unit_type is outside the defined range 0-40reportreport omitspec; cve; gwstructural
reserved-nal-presentgw-0QNEYJBDetect a NAL unit with a reserved type (10-15, 22-23, 24-31 or 41-47)removeremove report omitcve; gwstructural
unspecified-nal-presentgw-2K1QYQWDetect a NAL unit with an unspecified type (48-63)removeremove report omitcve; gwstructural
vcl-pps-reference-invalidgw-KD50SB0Detect a VCL NAL unit (types 0-31) that does not reference a valid PPSreportreport omitspec; gwfunctional

pps​

PPS must reference a valid SPS; invalid references cause uninitialized decoder state and parser crashes. Tile column/row counts control memory allocation for parallel decoding structures and crafted values cause heap buffer overflows (CVE-2020-21603); out-of-range reference counts and QP values cause array index violations.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
pps-absentgw-J5Y57PXDetect a stream with no PPS NAL unit (type 34) presentrejectreport omitspec; cve; gwfunctional
pps-cb-qp-offset-out-of-rangegw-7JW97K1Detect a pps_cb_qp_offset outside the range -12 to 12rejectreport omitspec; cve; gwfunctional
pps-cr-qp-offset-out-of-rangegw-9Z1CXQ9Detect a pps_cr_qp_offset outside the range -12 to 12rejectreport omitspec; cve; gwfunctional
pps-id-out-of-rangegw-GW6R3F1Detect a pps_pic_parameter_set_id outside the range 0-63rejectreport omitspec; cve; gwfunctional
pps-init-qp-out-of-rangegw-YD8QGSTDetect an init_qp_minus26 outside the range -26 to 25rejectreport omitspec; cve; gwfunctional
pps-ref-idx-l0-out-of-rangegw-XX1DHZ0Detect a num_ref_idx_l0_default_active_minus1 outside the range 0-14rejectreport omitspec; cve; gwfunctional
pps-ref-idx-l1-out-of-rangegw-R7J3X9EDetect a num_ref_idx_l1_default_active_minus1 outside the range 0-14rejectreport omitspec; cve; gwfunctional
pps-sps-reference-invalidgw-GD3TVNEDetect a pps_seq_parameter_set_id that does not reference a previously parsed SPSrejectreport omitspec; cve; gwfunctional
pps-tile-column-sum-inconsistentgw-H6Z2WRHDetect tile column widths that do not sum to PicWidthInCtbsYrejectreport omitspec; cve; gwfunctional
pps-tile-columns-out-of-rangegw-KXP6CV8Detect a num_tile_columns_minus1 outside the range 0-19 when tiles_enabled_flag is 1rejectreport omitspec; cve; gwfunctional
pps-tile-count-excessivegw-VV6X0THDetect a total tile count (columns times rows) exceeding 440 (Level 6.2 maximum)rejectreport omitspec; cve; gwfunctional
pps-tile-row-sum-inconsistentgw-YMJ5TA7Detect tile row heights that do not sum to PicHeightInCtbsYrejectreport omitspec; cve; gwfunctional
pps-tile-rows-out-of-rangegw-W1YPFV4Detect a num_tile_rows_minus1 outside the range 0-21 when tiles_enabled_flag is 1rejectreport omitspec; cve; gwfunctional

sei-messages​

SEI messages carry data no standard decoder needs to render video. user_data payloads are the primary H.265 data-hiding and exfiltration channel; pic_timing and recovery_point disclose decoding state; non-essential payloads carry hidden data; malformed type/size continuation encoding causes integer overflows and buffer over-reads.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
sei-hdr-metadata-presentgw-HJ75FABDetect a mastering_display_colour_volume (payloadType 137) or content_light_level_info (payloadType 144) HDR metadata SEI messagereportreport omitgwvisual
sei-non-essential-presentgw-HVHWE8SDetect a non-essential SEI message outside the retained (HDR metadata) setremoveremove report omitgwstructural
sei-payload-absentgw-BAZJZ0NDetect a SEI NAL unit containing no valid SEI payloadreportreport omitspec; cve; gwstructural
sei-recovery-point-presentgw-1N8H3ZCDetect a recovery_point (payloadType 6) SEI messageremoveremove report omitgwstructural
sei-size-out-of-boundsgw-N6X4G9HDetect a SEI payloadSize exceeding the remaining NAL unit bytesreportreport omitspec; cve; gwstructural
sei-timing-presentgw-BAYF6DYDetect a pic_timing (payloadType 1) SEI messageremoveremove report omitgwstructural
sei-type-encoding-invalidgw-0ZC9YDVDetect a SEI payloadType using an invalid 0xFF continuation encodingreportreport omitspec; cve; gwstructural
sei-user-data-presentgw-2XK8DY5Detect a user_data_registered_itu_t_t35 (payloadType 4) or user_data_unregistered (payloadType 5) SEI messageremoveremove report omitcve; gwstructural

slice-segments​

Slice segment headers reference PPS and reference-picture sets; invalid references cause decoder crashes and memory corruption.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
idr-slice-type-invalidgw-E7855VDDetect an IDR picture (NAL types 19-20) with slice_type not equal to 2 (I-slice)reportreport omitspec; gwfunctional
slice-first-flag-invalidgw-D93WJR3Detect a first_slice_segment_in_pic_flag not set to 1 for the first slice in a picturereportreport omitspec; gwfunctional
slice-nal-type-inconsistentgw-0J6MYHGDetect a slice NAL type inconsistent with the referenced PPS and SPSreportreport omitspec; cve; gwfunctional
slice-pps-reference-invalidgw-MBG96YYDetect a slice_pic_parameter_set_id that does not reference a valid PPSreportreport omitspec; cve; gwfunctional
slice-type-out-of-rangegw-5P7CKSPDetect a slice_type not equal to 0 (B), 1 (P) or 2 (I)reportreport omitspec; gwfunctional

sps​

SPS is the primary attack surface for H.265 decoder exploits (19+ CVEs in libde265). Invalid IDs cause cross-reference failures; crafted picture dimensions are the root cause of heap buffer overflows; excessive reference-picture and coding-tool values cause memory exhaustion, use-after-free and buffer over-reads.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
general-level-idc-invalidgw-6SW7NKNDetect a general_level_idc that Annex A does not define or that is too small for the coded picturereplacereplace report omitspec; gwstructural
sps-absentgw-B2YJ2CPDetect a stream with no SPS NAL unit (type 33) presentrejectreport omitspec; cve; gwfunctional
sps-bit-depth-chroma-out-of-rangegw-D8BNJV3Detect a bit_depth_chroma_minus8 outside the range 0-8rejectreport omitspec; cve; gwfunctional
sps-bit-depth-luma-out-of-rangegw-2SN0EHYDetect a bit_depth_luma_minus8 outside the range 0-8rejectreport omitspec; cve; gwfunctional
sps-cb-size-diff-out-of-rangegw-4F4SVK0Detect a log2_diff_max_min_luma_coding_block_size outside the range 0-3rejectreport omitspec; cve; gwfunctional
sps-chroma-format-invalidgw-FN6229TDetect a chroma_format_idc outside the range 0-3rejectreport omitspec; gwfunctional
sps-conformance-window-out-of-boundsgw-4F5YXEGDetect conformance-window crop offsets exceeding the picture dimensions when conformance_window_flag is 1replacereplace report omitspec; gwfunctional
sps-dimensions-excessivegw-FC45FXNDetect picture dimensions exceeding 16384 in either axisrejectreport omitspec; cve; gwfunctional
sps-dpb-size-out-of-rangegw-K41DYAFDetect an sps_max_dec_pic_buffering_minus1 outside the range 0-15 per sub-layerrejectreport omitspec; cve; gwfunctional
sps-id-out-of-rangegw-D7R1MDSDetect an sps_seq_parameter_set_id outside the range 0-15rejectreport omitspec; cve; gwfunctional
sps-latency-out-of-rangegw-HHKRD8DDetect an sps_max_latency_increase_plus1 outside its valid rangerejectreport omitspec; gwfunctional
sps-long-term-rps-count-out-of-rangegw-WP8AM00Detect a num_long_term_ref_pics_sps outside the range 0-32rejectreport omitspec; cve; gwfunctional
sps-min-cb-size-out-of-rangegw-AB721DCDetect a log2_min_luma_coding_block_size_minus3 outside the range 0-3rejectreport omitspec; cve; gwfunctional
sps-min-tb-size-out-of-rangegw-N4QK50HDetect a log2_min_luma_transform_block_size_minus2 outside the range 0-3rejectreport omitspec; cve; gwfunctional
sps-pic-height-out-of-rangegw-GNV87T6Detect a pic_height_in_luma_samples outside the range 1-16384rejectreport omitspec; cve; gwfunctional
sps-pic-width-out-of-rangegw-1ADR3FVDetect a pic_width_in_luma_samples outside the range 1-16384rejectreport omitspec; cve; gwfunctional
sps-pixel-count-excessivegw-CJJMYS6Detect a pic_width times pic_height product exceeding 268435456 luma samplesrejectreport omitspec; cve; gwfunctional
sps-poc-range-out-of-rangegw-G5KQTS9Detect a log2_max_pic_order_cnt_lsb_minus4 outside the range 0-12rejectreport omitspec; cve; gwfunctional
sps-reorder-pics-inconsistentgw-5Y1V1D5Detect an sps_max_num_reorder_pics greater than sps_max_dec_pic_buffering_minus1rejectreport omitspec; cve; gwfunctional
sps-short-term-rps-count-out-of-rangegw-2EV5742Detect a num_short_term_ref_pic_sets outside the range 0-64rejectreport omitspec; cve; gwfunctional
sps-sub-layer-count-out-of-rangegw-0E0FD82Detect an sps_max_sub_layers_minus1 outside the range 0-6rejectreport omitspec; gwfunctional
sps-tb-size-diff-out-of-rangegw-V39BM3CDetect a log2_diff_max_min_luma_transform_block_size outside the range 0-3rejectreport omitspec; cve; gwfunctional
sps-tx-depth-inter-out-of-rangegw-XMDTTTJDetect a max_transform_hierarchy_depth_inter outside the range 0-4rejectreport omitspec; cve; gwfunctional
sps-tx-depth-intra-out-of-rangegw-RCQC2C6Detect a max_transform_hierarchy_depth_intra outside the range 0-4rejectreport omitspec; cve; gwfunctional
sps-vps-reference-invalidgw-1E184B2Detect an sps_video_parameter_set_id that does not reference a previously parsed VPSrejectreport omitspec; cve; gwfunctional

stream-format​

Missing or malformed start codes prevent NAL unit boundary detection and may indicate a crafted stream designed to exploit parser desynchronization between Genesis and the decoder.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
leading-gap-content-presentgw-G997AWWDetect non-zero data before the first start code prefixremoveremove report omitspec; gwstructural
nal-unit-size-below-minimumgw-1FEKERMDetect a NAL unit shorter than the 2-byte minimum H.265 NAL header sizereportreport omitspec; gwstructural
start-code-absent-unparseablegw-KZPPJR0Detect a stream in which no valid start code can be foundrejectreport omitspec; gwstructural
start-code-integrity-invalidgw-RX4X10QDetect a NAL unit not preceded by a valid start code prefixreportreport omitspec; gwstructural
start-code-prefix-missinggw-GDP6QW1Detect a stream that does not begin with a start code prefix (0x000001 or 0x00000001)reportreport omitspec; gwstructural

structural-integrity​

Resource exhaustion from excessive NAL counts, oversized streams or parameter-set bombing; emulation-prevention byte errors cause parser desynchronization; reserved bits flagged by ITU-T H.265 carry no decoder semantics and a non-zero value is a steganographic signal.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
emulation-prevention-invalidgw-14RKGY7Detect an invalid emulation-prevention byte (0x03 after 0x0000) within a NAL payloadreportreport omitspec; gwstructural
nal-count-excessivegw-9D25GPRDetect a NAL unit count exceeding the configured maximum (default 100000)reportreport omitspec; gwstructural
parameter-set-id-conflictgw-376BAJTDetect two parameter sets that share an id while coding different picturesremoveremove report omitspec; gwstructural
pps-count-excessivegw-8QKGFN6Detect a PPS count exceeding 64reportreport omitspec; gwstructural
reserved-fields-nonzerogw-VSPRES0Detect non-zero reserved padding bits in the RBSP trailing byte of a VPS/SPS/PPS parameter setreplacereplace report omitspec; gwstructural
sps-count-excessivegw-ZQ4H44CDetect an SPS count exceeding 16reportreport omitspec; gwstructural
stream-size-excessivegw-P9BPD5JDetect a total stream size exceeding the configured maximum (default 1 GB)reportreport omitspec; gwstructural
vcl-nal-absentgw-43DC8ACDetect a stream with no VCL NAL unit (types 0-9, 16-21) presentreportreport omitspec; gwstructural
vps-count-excessivegw-BGDEJXHDetect a VPS count exceeding 16reportreport omitspec; gwstructural

trailing-data​

Data after the last NAL unit or after an end_of_bitstream NAL is not part of the H.265 stream and may contain hidden content, appended payloads or polyglot data.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
content-after-end-of-streamgw-2E8XTVWDetect NAL units that follow the end-of-sequence or end-of-bitstream NAL unitremoveremove report omitspec; gwstructural
trailing-data-after-eob-invalidgw-TSCHX54Detect data present after the end_of_bitstream NAL unit (type 37)reportreport omitspec; gwstructural
trailing-data-presentgw-67P1QK6Detect data present after the last NAL unit in the streamremoveremove report omitgwstructural

vps​

The VPS defines the overall video coding configuration. Missing VPS prevents correct stream initialization; crafted layer/sub-layer counts cause allocation overflows; crafted timing values cause integer overflows in frame-rate calculations (CVE-2024-31585 FFmpeg HRD overflow).

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
vps-absentgw-FRSPS4YDetect a stream with no VPS NAL unit (type 32) presentrejectreport omitspec; gwfunctional
vps-id-out-of-rangegw-8T34QPKDetect a vps_video_parameter_set_id outside the range 0-15rejectreport omitspec; gwfunctional
vps-layer-count-invalidgw-8VWT9E1Detect a vps_max_layers_minus1 not equal to 0 in a single-layer streamrejectreport omitspec; gwfunctional
vps-sub-layer-count-out-of-rangegw-0FYZEJADetect a vps_max_sub_layers_minus1 outside the range 0-6rejectreport omitspec; gwfunctional
vps-temporal-nesting-invalidgw-GV6HZFEDetect a vps_temporal_id_nesting_flag not set to 1 when vps_max_sub_layers_minus1 is 0rejectreport omitspec; gwfunctional
vps-time-scale-invalidgw-27M6911Detect a vps_time_scale of 0 when timing information is presentreplacereplace report omitspec; cve; gwfunctional
vps-timing-units-invalidgw-D8EG91BDetect a vps_num_units_in_tick of 0 when timing information is presentreplacereplace report omitspec; cve; gwfunctional

SIDD (sidd)​

annotations​

Excessive annotation counts cause rendering DoS. Oversized annotation text fields can carry covert channel data. Invalid geometry coordinates can cause renderer crashes.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
annotation-count-excessivegw-0VWADCHDetect more than 1000 annotations (rendering denial-of-service vector)rejectreport omitspec; gwfunctional
annotation-count-invalidgw-1Q2AB6QDetect a total annotation count exceeding 1000reportreport omitspec; gwfunctional
annotation-identifier-invalidgw-Q629WZDDetect an Annotation/Identifier that is empty or longer than 256 charactersreportreport omitspec; gwfunctional
line-vertices-invalidgw-DSY4R9TDetect line geometry with fewer than 2 vertices or invalid coordinatesreportreport omitspec; gwfunctional
point-vertices-invalidgw-057GREVDetect point geometry with non-finite coordinatesreportreport omitspec; gwfunctional
polygon-vertices-invalidgw-BS035SQDetect polygon geometry with fewer than 3 vertices or invalid coordinatesreportreport omitspec; gwfunctional
text-length-invalidgw-0Z5DT6WDetect annotation text content exceeding 4096 charactersreportreport omitspec; gwfunctional

classification​

Classification marking tampering is the highest-risk threat for SIDD files. Mismatched markings between SIDD XML and NITF headers cause security spillage, an unregistered codeword or releasability value grants handling no register defines, and markings that contradict each other let a reader who honors one of them under-protect the product.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
classification-marking-confusablegw-RTWES0XDetect a SIDD classification that matches the NITF security fields only after unicode foldingrejectreport omitgw; analogyfunctional
declassification-marking-incoherentgw-QGZQ12ZDetect declassification instructions that contradict the classification or each otherrejectreport omitspec; gwfunctional
declassification-marking-invalidgw-00N9G0BDetect a declassification instruction outside the IC-ISM exemption registerreportreport omitspec; gwfunctional
dissemination-marking-invalidgw-NKN89NCDetect a dissemination control marking outside the IC-ISM registerreportreport omitspec; gwfunctional
marking-exceeds-levelgw-9QKJ44WDetect a compartment or restricted-data marking on unclassified contentrejectreport omitspec; gwfunctional
marking-token-limit-exceededgw-MMEWKVWDetect a marking list carrying more tokens than the IC-ISM schema permitsreportreport omitspec; gwfunctional
releasability-marking-incoherentgw-43873GBDetect releasability and dissemination markings that contradict each otherrejectreport omitspec; gwfunctional
releasability-marking-invalidgw-XN0ASSHDetect a releasability marking outside the IC-ISM country registerreportreport omitspec; gwfunctional
required-marking-absentgw-6TR4PZZDetect a required IC-ISM marking absent from the Classification elementrejectreport omitspec; gwfunctional
security-classification-invalidgw-CJHN188Detect a classification level outside the IC-ISM portion-mark registerreportreport omitspec; gwfunctional
security-control-system-invalidgw-1ST95XKDetect a control-system marking outside the IC-ISM codeword registerreportreport omitspec; gwfunctional
security-policy-identifier-invalidgw-FS95YTKDetect a compliance declaration outside the IC-ISM registerreportreport omitspec; gwfunctional

des-identification​

Non-standard DESID values could bypass SIDD detection. DES count mismatches indicate structural tampering. Version mismatches may cause parser confusion. A DES that shares the XML_DATA_CONTENT identifier but carries a non-SIDD dialect (e.g. SICD) is content the SIDD camera cannot inspect and must not pass through unremediated.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
data-length-invalidgw-SDRRAYBDetect a DES data length inconsistent with the actual XML content sizereportreport omitspec; gwfunctional
des-count-invalidgw-REK69W3Detect a NUMDES in the NITF header inconsistent with the actual DES segment countreportreport omitspec; gwfunctional
des-identifier-invalidgw-HM4A51TDetect a DES identifier (DESID) that is not 'XML_DATA_CONTENT' for a SIDD DESreportreport omitspec; gwfunctional
des-version-invalidgw-T0MY6CJDetect a DES version (DESVER) that is not a valid SIDD versionreportreport omitspec; gwfunctional
sidd-des-missinggw-Q7CMXF2Detect no DES segment carrying SIDD XML metadatarejectreport omitspec; gwfunctional
unsupported-schema-versiongw-T57H90CDetect a recognized SIDD-family namespace (SIDD / SICommon / SFA / IC-ISM) declared at a schema version Genesis does not supportrejectreport omitgwfunctional
unsupported-xml-desgw-SDCXDESDetect an XML_DATA_CONTENT DES whose XML root is not a SIDD namespace (unsupported variant, e.g. SICD)rejectreport omitisg; gwfunctional

display​

Invalid pixel type or band count values can cause buffer miscalculation in image renderers. Inconsistent band indices cause out-of-bounds access.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
band-count-invalidgw-91YSXCQDetect a NumBands inconsistent with PixelType (1 for mono types, 3 for RGB types)reportreport omitspec; gwfunctional
band-indices-invalidgw-ZJQ2CX3Detect a DefaultBandDisplay index outside the range 1 to NumBandsreportreport omitspec; gwfunctional
downsampling-method-invalidgw-HQPDMRJDetect a DownsamplingMethod that is not a valid enumeration valuereportreport omitspec; gwfunctional
pixel-type-invalidgw-1QD19NYDetect a PixelType other than MONO8I, MONO8LU, MONO16I, RGB8LU or RGB24Ireportreport omitspec; gwfunctional

downstream-reprocessing​

Zero or negative chip dimensions can cause buffer allocation errors in downstream processors.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
chip-size-column-invalidgw-VVQPFH5Detect a GeometricChip/ChipSize/Col that is not a positive integerreportreport omitspec; gwfunctional
chip-size-row-invalidgw-X7MMGSHDetect a GeometricChip/ChipSize/Row that is not a positive integerreportreport omitspec; gwfunctional

exploitation-features​

Invalid collection geometry angles can mislead SAR image interpretation. Non-finite resolution values cause rendering errors.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
azimuth-invalidgw-MN58M6KDetect a Geometry/Azimuth outside the range 0.0 to 360.0 degreesreportreport omitspec; gwfunctional
collection-datetime-invalidgw-GQ1469ZDetect a Collection/DateTime that is not a valid ISO 8601 datetimereportreport omitspec; gwfunctional
collection-duration-invalidgw-G190WXVDetect a CollectionDuration that is not positive and finitereportreport omitspec; gwfunctional
collection-identifier-invalidgw-JSMB9H3Detect a Collection/Identifier that is empty or longer than 256 charactersreportreport omitspec; gwfunctional
doppler-cone-angle-invalidgw-RXBE629Detect a Geometry/DopplerConeAngle outside the range 0 to under 180 degreesreportreport omitspec; gwfunctional
ellipticity-invalidgw-WP9N4WZDetect a Product/Ellipticity that is not positive and finitereportreport omitspec; gwfunctional
graze-invalidgw-SP3K0TPDetect a Geometry/Graze outside the range 0.0 to 90.0 degreesreportreport omitspec; gwfunctional
ground-track-angle-invalidgw-0EJ93RZDetect a Phenomenology/GroundTrack angle outside the range -180 to 180 degreesreportreport omitspec; gwfunctional
layover-magnitude-invalidgw-MB1H8VXDetect a Phenomenology/Layover magnitude that is not positive and finitereportreport omitspec; gwfunctional
multipath-angle-invalidgw-YAV8V4CDetect a Phenomenology/MultiPath angle outside the range -180 to 180 degreesreportreport omitspec; gwfunctional
north-angle-invalidgw-BMVB1DHDetect a Product/North angle outside the range -180 to 180 degreesreportreport omitspec; gwfunctional
polarization-invalidgw-TAPVM25Detect a processed polarization outside the SICommon enumerationreportreport omitspec; gwfunctional
resolution-column-invalidgw-5M4Z8ZMDetect a Product/Resolution/Col that is not a positive finite valuereportreport omitspec; gwfunctional
resolution-row-invalidgw-S2BV02EDetect a Product/Resolution/Row that is not a positive finite valuereportreport omitspec; gwfunctional
sensor-name-invalidgw-XCG08KDDetect a Collection/Information/SensorName that is empty or over-longreportreport omitspec; gwfunctional
shadow-magnitude-invalidgw-QGXJR6TDetect a Phenomenology/Shadow magnitude that is not positive and finitereportreport omitspec; gwfunctional
slope-invalidgw-RS97C0GDetect a Geometry/Slope outside the range 0.0 to 90.0 degreesreportreport omitspec; gwfunctional
squint-invalidgw-1XA7EF7Detect a Geometry/Squint outside the range -180.0 to 180.0 degreesreportreport omitspec; gwfunctional
tilt-invalidgw-VT69Z5XDetect a Geometry/Tilt outside the range -90.0 to 90.0 degreesreportreport omitspec; gwfunctional

geodata​

Geographic coordinate spoofing places imagery at incorrect locations, potentially misleading intelligence analysts. Invalid earth model references cause projection errors.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
corner-count-invalidgw-N1HN5A4Detect image corner points other than exactly four with correct index valuesreportreport omitspec; gwfunctional
corner-latitudes-invalidgw-CCW5KA6Detect an image corner point latitude outside the range -90.0 to 90.0reportreport omitspec; gwfunctional
corner-longitudes-invalidgw-D78DPFVDetect an image corner point longitude outside the range -180.0 to 180.0reportreport omitspec; gwfunctional
data-bounds-invalidgw-KQ6KFJ6Detect a ValidData vertex outside the geographic range or the image boundsreportreport omitspec; gwfunctional
data-vertices-invalidgw-NXH4FJSDetect ValidData with fewer than 3 verticesreportreport omitspec; gwfunctional
earth-model-invalidgw-MG49660Detect an EarthModel other than 'WGS_84'reportreport omitspec; gwfunctional

measurement​

Zero or negative pixel footprint dimensions cause division-by-zero in renderers. NaN or Infinity polynomial coefficients cause floating-point exceptions. Dimension mismatches between SIDD XML and NITF headers indicate structural tampering.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
arp-polynomial-invalidgw-RJ56GVHDetect ARPPoly X/Y/Z coefficients that are not finite (NaN or Infinity)reportreport omitspec; gwfunctional
footprint-column-invalidgw-C902ACTDetect a PixelFootprint/Col outside the range 1 to 100000reportreport omitspec; gwfunctional
footprint-nitf-inconsistentgw-VKEP08WDetect a PixelFootprint inconsistent with the NITF image dimensionsreportreport omitspec; gwfunctional
footprint-row-invalidgw-ZPP3VTADetect a PixelFootprint/Row outside the range 1 to 100000reportreport omitspec; gwfunctional
projection-type-invalidgw-A7X6B6HDetect a projection element that is not one of the four schema choicesreportreport omitspec; gwfunctional
time-coa-polynomial-invalidgw-Q2CYXWNDetect TimeCOAPoly coefficients that are not finite (NaN or Infinity)reportreport omitspec; gwfunctional

metadata-content-safety​

Schema-legitimate free-text metadata fields cannot be blanked without breaking a valid SIDD product, so a smuggled string (an external URI, a printf format specifier, a prototype-pollution key name or a Unicode bidi/zero-width control) survives CDR byte-for-byte. Genesis never dereferences or interprets these values, so there is no in-process exploit; the residual is covert-channel carriage and downstream-consumer risk. Detecting them keeps a carrier file from being reported fully clean, and the opt-in removals excise the smuggled substring while preserving the surrounding field text.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
bidi-control-presentgw-JAVH938Detect Unicode bidirectional or zero-width format controls in free-text product metadatareportreport remove omitgw; analogyfunctional
external-uri-presentgw-ZD2XT8EDetect an external URI or network reference (http/https/ftp/file scheme or UNC path) in free-text product metadatareportreport remove omitgwfunctional
format-specifier-presentgw-3KATT09Detect potential printf-style format specifiers (for example %n or %s) in free-text product metadatareportreport remove omitgwfunctional
prototype-pollution-token-presentgw-YKTE7V9Detect potential JavaScript prototype-pollution key names (for example proto or constructor.prototype) in free-text product metadatareportreport omitgwfunctional

nitf-cross-validation​

Mismatches between SIDD XML metadata and NITF header fields indicate structural tampering, potential security marking spillage or deliberate parser confusion attacks. A marking divergence is spillage in either direction: a reader that honors the container ignores what the XML declares, and a reader that honors the XML ignores what the container declares.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
compartment-marking-undeclaredgw-GBF3505Detect a NITF codeword field asserting a compartment the SIDD XML does not declarereportreport omitgwfunctional
declassification-marking-undeclaredgw-1J738J1Detect a NITF declassification date the SIDD XML does not declare in any formreportreport omitgwfunctional
declassification-nitf-mismatchgw-3MY6B2ADetect SIDD declassification instructions that disagree with the NITF declassification fieldsrejectreport omitspec; gwfunctional
des-count-inconsistentgw-TMKRTBSDetect a NUMDES in the NITF file header inconsistent with the actual DES segment countreportreport omitspec; gwfunctional
dimension-column-inconsistentgw-PRS36KRDetect a PixelFootprint/Col inconsistent with the NITF image segment NCOLSreportreport omitspec; gwfunctional
dimension-row-inconsistentgw-7AH5PH7Detect a PixelFootprint/Row inconsistent with the NITF image segment NROWSreportreport omitspec; gwfunctional
dissemination-nitf-mismatchgw-PXE61YDDetect a NITF releasability field that releases content the SIDD XML marks NOFORNrejectreport omitspec; gwfunctional
file-classification-mismatchgw-N9THCGYDetect a SIDD classification that does not match the NITF file-level security classificationrejectreport omitspec; gwfunctional
image-category-invalidgw-81R2SR5Detect a NITF ICAT other than 'SAR' or an appropriate value for SAR-derived imageryreportreport omitspec; gwfunctional
multiple-sidd-desgw-K357JJKDetect other than exactly one SIDD XML DES per image productreportreport omitspec; gwfunctional
segment-classification-mismatchgw-Z6R16QYDetect a NITF segment subheader classification inconsistent with the SIDD product classificationrejectreport omitspec; gwfunctional

product-creation​

Oversized string fields in ProductCreation can be used for data hiding. Invalid processing timestamps could indicate tampering.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
processing-datetime-invalidgw-NTS4689Detect a ProcessorInformation/ProcessingDateTime that is not a valid ISO 8601 datetimereportreport omitspec; gwfunctional
processor-application-invalidgw-6XP7AG2Detect a ProcessorInformation/Application that is empty or longer than 256 charactersreportreport omitspec; gwfunctional
processor-site-invalidgw-V81NDY1Detect a ProcessorInformation/Site longer than 256 charactersreportreport omitspec; gwfunctional
product-class-invalidgw-89F9CAMDetect a ProductClass that is empty or longer than 256 charactersreportreport omitspec; gwfunctional
product-name-invalidgw-5Y8411VDetect a ProductName that is empty or longer than 1024 charactersreportreport omitspec; gwfunctional
product-type-invalidgw-2FX9F0CDetect a ProductType longer than 256 charactersreportreport omitspec; gwfunctional

product-processing​

Excessive processing module chains can indicate data smuggling. Oversized module names can carry hidden data.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
module-count-invalidgw-FSS7ZY4Detect a processing module count exceeding 100reportreport omitspec; gwfunctional
module-name-invalidgw-3QTTNJADetect a ProcessingModule/ModuleName that is empty or longer than 256 charactersreportreport omitspec; gwfunctional

required-elements​

Missing required elements indicate a malformed or truncated SIDD document that could confuse downstream processors or bypass validation.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
display-missinggw-YYXY3FQDetect a Display element that is missing or emptyreportreport omitspec; gwfunctional
exploitation-features-missinggw-X7P4QMADetect an ExploitationFeatures element that is missing or emptyreportreport omitspec; gwfunctional
geo-data-missinggw-JMB6FZDDetect a GeoData element that is missing or emptyreportreport omitspec; gwfunctional
measurement-missinggw-49WNGHSDetect a Measurement element that is missing or emptyreportreport omitspec; gwfunctional
product-creation-missinggw-K82V8TNDetect a ProductCreation element that is missing or emptyreportreport omitspec; gwfunctional
sidd-root-invalidgw-AR9HBBZDetect a root element other than 'SIDD' with a valid namespacereportreport omitspec; gwfunctional

schema-coverage​

A SIDD that violates the XSD occurrence / choice / enumeration constraints is self-inconsistent: a duplicate of a singleton element, more than one projection choice or an out-of-range enumerated value can drive divergent interpretations across downstream consumers - a parser-differential surface.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
choice-violationgw-Z4853N6Detect more than one branch of an xs:choice group present under the same parentreportreport omitspec; gwstructural
declared-count-mismatchgw-4TQZP8NDetect a declared count attribute that disagrees with the elements it describesreplacereplace report omitspec; gwstructural
duplicate-elementgw-7SSCTKSDetect a SIDD element that appears more times under its parent than the schema permitsreportreport omitspec; gwstructural
enumeration-value-invalidgw-8XGWSFVDetect a closed-enumeration SIDD element carrying a value outside its schema value spacereportreport omitspec; gwstructural
non-finite-number-presentgw-7QGFGQBDetect a NaN or infinite value in a field whose schema type admits itreportreport remove omitgw; analogyfunctional
numeric-value-invalidgw-W2DGXB2Detect a numeric value outside the value space its schema type declaresrejectreport omitspec; gw; analogystructural
polynomial-order-mismatchgw-9BVK37XDetect polynomial coefficients that contradict the order the polynomial declaresreportreport omitspec; gwstructural

xml-structure​

DOCTYPE declarations enable XXE injection (SSRF, file disclosure, DoS). Processing instructions can load external resources. CDATA sections and comments can smuggle hidden data. Namespace redirection can point to attacker-controlled schemas.

RuleIDDetectsDefaultConfigurable actionsComplianceImpact
cdata-sections-presentgw-6KC9E6RDetect CDATA sections that may carry smuggled contentreplacereplace report omitgwstructural
extension-attributes-presentgw-FHWD2DEDetect non-schema attributes on known SIDD elementsremoveremove report omitgwstructural
extra-namespaces-presentgw-G8Z6XZ4Detect namespace declarations beyond the SIDD namespaceremoveremove report omitgwstructural
namespace-uri-invalidgw-K1EJW4DDetect a root element namespace that is not a supported SIDD version (1.0.0 / 2.0.0 / 3.0.0)reportreport omitspec; gwstructural
processing-instructions-presentgw-E823KNZDetect XML processing instructions other than the XML declarationremoveremove report omitgwstructural
unknown-elements-presentgw-DCSXWT0Detect XML elements not defined in the SIDD schemaremoveremove report omitgwstructural
xinclude-presentgw-DEV6W3GDetect W3C XInclude directives in the SIDD XML—DOCTYPE-independent external file inclusion / SSRFremoveremove report omitgwstructural
xml-comments-presentgw-VEW0J03Detect XML comments that may carry covert-channel hidden dataremoveremove report omitgwstructural
xml-doctype-presentgw-F4XE4P0Detect a DOCTYPE declaration in the SIDD XML (XXE injection vector)rejectreport omitgwstructural
xml-null-bytes-presentgw-KR0ZCMWDetect null bytes in SIDD XML string valuesrejectreport omitgwstructural
xml-size-invalidgw-CJ0YW13Detect a total XML size exceeding 10 MBrejectreport omitspec; gwstructural