695 lines
19 KiB
Go
695 lines
19 KiB
Go
package stego
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/zlib"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
|
|
"github.com/andydixon/nexus/internal/leviathan/document"
|
|
)
|
|
|
|
// MetaEntry is one piece of textual/EXIF metadata recovered from an image.
|
|
type MetaEntry struct {
|
|
Offset int64 `json:"offset"`
|
|
Length int64 `json:"length"`
|
|
Container string `json:"container"`
|
|
Kind string `json:"kind"`
|
|
Keyword string `json:"keyword"`
|
|
Value string `json:"value"`
|
|
Note string `json:"note,omitempty"`
|
|
}
|
|
|
|
// ScanMetadata walks PNG chunks or JPEG segments (APPn / COM) and decodes
|
|
// human-readable metadata. Output is best-effort — malformed containers
|
|
// return whatever has been parsed up to the failure point.
|
|
func ScanMetadata(d *document.Document) ([]MetaEntry, error) {
|
|
size := d.Size()
|
|
if size < 8 {
|
|
return nil, errors.New("file too small")
|
|
}
|
|
head, err := d.Range(0, minInt64(16, size))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch {
|
|
case len(head) >= 8 && string(head[:8]) == "\x89PNG\r\n\x1a\n":
|
|
return scanPNGMeta(d)
|
|
case len(head) >= 3 && head[0] == 0xff && head[1] == 0xd8 && head[2] == 0xff:
|
|
return scanJPEGMeta(d)
|
|
case len(head) >= 6 && (string(head[:6]) == "GIF87a" || string(head[:6]) == "GIF89a"):
|
|
return scanGIFMeta(d)
|
|
}
|
|
return nil, errors.New("unsupported container (PNG, JPEG and GIF handled)")
|
|
}
|
|
|
|
func scanPNGMeta(d *document.Document) ([]MetaEntry, error) {
|
|
size := d.Size()
|
|
out := []MetaEntry{}
|
|
off := int64(8)
|
|
for off+12 <= size {
|
|
hdr, err := d.Range(off, 8)
|
|
if err != nil {
|
|
break
|
|
}
|
|
ln := int64(binary.BigEndian.Uint32(hdr[0:4]))
|
|
typ := string(hdr[4:8])
|
|
if ln < 0 || off+12+ln > size {
|
|
break
|
|
}
|
|
if typ == "tEXt" || typ == "zTXt" || typ == "iTXt" {
|
|
data, err := d.Range(off+8, ln)
|
|
if err == nil {
|
|
entry := decodePNGTextChunk(typ, data)
|
|
entry.Offset = off
|
|
entry.Length = 12 + ln
|
|
entry.Container = "png"
|
|
out = append(out, entry)
|
|
}
|
|
}
|
|
off += 12 + ln
|
|
if typ == "IEND" {
|
|
break
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func decodePNGTextChunk(typ string, data []byte) MetaEntry {
|
|
e := MetaEntry{Kind: typ}
|
|
i := bytes.IndexByte(data, 0)
|
|
if i < 0 {
|
|
e.Note = "no keyword separator"
|
|
e.Value = safeText(data)
|
|
return e
|
|
}
|
|
e.Keyword = string(data[:i])
|
|
rest := data[i+1:]
|
|
switch typ {
|
|
case "tEXt":
|
|
e.Value = safeText(rest)
|
|
case "zTXt":
|
|
if len(rest) < 1 {
|
|
e.Note = "truncated"
|
|
return e
|
|
}
|
|
// rest[0] = compression method (0 = zlib)
|
|
method := rest[0]
|
|
raw, err := zlibDecompress(rest[1:])
|
|
if err != nil {
|
|
e.Note = fmt.Sprintf("zlib fail (method=%d): %v", method, err)
|
|
return e
|
|
}
|
|
e.Value = safeText(raw)
|
|
case "iTXt":
|
|
// compression flag, compression method, language tag\0, translated keyword\0, text
|
|
if len(rest) < 2 {
|
|
e.Note = "truncated"
|
|
return e
|
|
}
|
|
compressed := rest[0] == 1
|
|
rest = rest[2:]
|
|
j := bytes.IndexByte(rest, 0)
|
|
if j < 0 {
|
|
e.Value = safeText(rest)
|
|
return e
|
|
}
|
|
lang := string(rest[:j])
|
|
rest = rest[j+1:]
|
|
k := bytes.IndexByte(rest, 0)
|
|
if k < 0 {
|
|
e.Value = safeText(rest)
|
|
return e
|
|
}
|
|
trk := string(rest[:k])
|
|
rest = rest[k+1:]
|
|
if compressed {
|
|
if raw, err := zlibDecompress(rest); err == nil {
|
|
rest = raw
|
|
} else {
|
|
e.Note = "zlib fail: " + err.Error()
|
|
}
|
|
}
|
|
v := safeText(rest)
|
|
if lang != "" || trk != "" {
|
|
v = fmt.Sprintf("[%s/%s] %s", lang, trk, v)
|
|
}
|
|
e.Value = v
|
|
}
|
|
return e
|
|
}
|
|
|
|
func scanJPEGMeta(d *document.Document) ([]MetaEntry, error) {
|
|
size := d.Size()
|
|
out := []MetaEntry{}
|
|
off := int64(2) // skip SOI
|
|
for off+4 <= size {
|
|
hdr, err := d.Range(off, 2)
|
|
if err != nil || hdr[0] != 0xff {
|
|
break
|
|
}
|
|
marker := hdr[1]
|
|
// Standalone markers (no payload): SOI/EOI/RSTn
|
|
if marker == 0xd9 || marker == 0xd8 || (marker >= 0xd0 && marker <= 0xd7) {
|
|
off += 2
|
|
continue
|
|
}
|
|
// Read segment length (big-endian, includes the length bytes themselves)
|
|
lnBytes, err := d.Range(off+2, 2)
|
|
if err != nil {
|
|
break
|
|
}
|
|
segLen := int64(binary.BigEndian.Uint16(lnBytes))
|
|
if segLen < 2 || off+2+segLen > size {
|
|
break
|
|
}
|
|
payload, err := d.Range(off+4, segLen-2)
|
|
if err != nil {
|
|
break
|
|
}
|
|
switch {
|
|
case marker == 0xfe: // COM
|
|
out = append(out, MetaEntry{
|
|
Offset: off, Length: 2 + segLen,
|
|
Container: "jpeg", Kind: "COM",
|
|
Value: safeText(payload),
|
|
})
|
|
case marker == 0xe1: // APP1 — EXIF / XMP
|
|
entries := decodeJPEGApp1(payload)
|
|
for _, e := range entries {
|
|
e.Offset = off
|
|
e.Length = 2 + segLen
|
|
e.Container = "jpeg"
|
|
out = append(out, e)
|
|
}
|
|
case marker == 0xe0: // APP0 — JFIF
|
|
out = append(out, MetaEntry{
|
|
Offset: off, Length: 2 + segLen,
|
|
Container: "jpeg", Kind: "APP0",
|
|
Keyword: sniffMarker(payload),
|
|
Value: fmt.Sprintf("%d bytes", len(payload)),
|
|
})
|
|
case marker >= 0xe2 && marker <= 0xef: // APP2..APP15
|
|
out = append(out, MetaEntry{
|
|
Offset: off, Length: 2 + segLen,
|
|
Container: "jpeg", Kind: fmt.Sprintf("APP%d", marker-0xe0),
|
|
Keyword: sniffMarker(payload),
|
|
Value: fmt.Sprintf("%d bytes", len(payload)),
|
|
})
|
|
}
|
|
off += 2 + segLen
|
|
// SOS (Start of Scan) — entropy-coded data follows, stop walking.
|
|
if marker == 0xda {
|
|
break
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func sniffMarker(p []byte) string {
|
|
i := bytes.IndexByte(p, 0)
|
|
if i < 0 || i > 16 {
|
|
if len(p) > 16 {
|
|
return string(p[:16])
|
|
}
|
|
return ""
|
|
}
|
|
return string(p[:i])
|
|
}
|
|
|
|
func decodeJPEGApp1(p []byte) []MetaEntry {
|
|
out := []MetaEntry{}
|
|
if len(p) >= 6 && string(p[:6]) == "Exif\x00\x00" {
|
|
tiff := p[6:]
|
|
entries, err := decodeEXIF(tiff)
|
|
if err == nil {
|
|
out = append(out, entries...)
|
|
} else {
|
|
out = append(out, MetaEntry{Kind: "APP1/EXIF", Note: err.Error()})
|
|
}
|
|
return out
|
|
}
|
|
if len(p) >= 28 && string(p[:28]) == "http://ns.adobe.com/xap/1.0/" {
|
|
xmp := p[29:]
|
|
out = append(out, MetaEntry{
|
|
Kind: "APP1/XMP", Keyword: "xmp", Value: safeText(xmp),
|
|
})
|
|
return out
|
|
}
|
|
out = append(out, MetaEntry{
|
|
Kind: "APP1", Keyword: sniffMarker(p), Value: fmt.Sprintf("%d bytes", len(p)),
|
|
})
|
|
return out
|
|
}
|
|
|
|
// EXIF reader: TIFF header + IFD0 + IFD1 + Exif SubIFD + GPS SubIFD +
|
|
// Interoperability IFD. Handles ASCII/BYTE/SHORT/LONG/RATIONAL/SRATIONAL
|
|
// values, plus UNDEFINED as hex preview. Detects MakerNote presence.
|
|
func decodeEXIF(tiff []byte) ([]MetaEntry, error) {
|
|
if len(tiff) < 8 {
|
|
return nil, errors.New("short TIFF header")
|
|
}
|
|
var bo binary.ByteOrder
|
|
switch string(tiff[:2]) {
|
|
case "II":
|
|
bo = binary.LittleEndian
|
|
case "MM":
|
|
bo = binary.BigEndian
|
|
default:
|
|
return nil, errors.New("bad TIFF byte-order mark")
|
|
}
|
|
if bo.Uint16(tiff[2:4]) != 0x002a {
|
|
return nil, errors.New("bad TIFF magic")
|
|
}
|
|
ifd0 := int(bo.Uint32(tiff[4:8]))
|
|
out := []MetaEntry{}
|
|
ptrs := ifdPointers{}
|
|
nextIFD := 0
|
|
out = append(out, readIFD(tiff, ifd0, bo, "IFD0", &ptrs, &nextIFD)...)
|
|
// IFD1 (thumbnail) if present.
|
|
if nextIFD > 0 {
|
|
out = append(out, readIFD(tiff, nextIFD, bo, "IFD1", nil, nil)...)
|
|
}
|
|
if ptrs.exif > 0 {
|
|
out = append(out, readIFD(tiff, ptrs.exif, bo, "ExifIFD", &ptrs, nil)...)
|
|
}
|
|
if ptrs.gps > 0 {
|
|
out = append(out, readIFD(tiff, ptrs.gps, bo, "GPSIFD", nil, nil)...)
|
|
}
|
|
if ptrs.interop > 0 {
|
|
out = append(out, readIFD(tiff, ptrs.interop, bo, "InteropIFD", nil, nil)...)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
type ifdPointers struct {
|
|
exif int
|
|
gps int
|
|
interop int
|
|
}
|
|
|
|
func readIFD(tiff []byte, off int, bo binary.ByteOrder, name string, ptrs *ifdPointers, nextPtr *int) []MetaEntry {
|
|
out := []MetaEntry{}
|
|
if off < 0 || off+2 > len(tiff) {
|
|
return out
|
|
}
|
|
n := int(bo.Uint16(tiff[off : off+2]))
|
|
base := off + 2
|
|
// Cap directory count to head off hostile input.
|
|
if n > 512 {
|
|
n = 512
|
|
}
|
|
for i := 0; i < n; i++ {
|
|
p := base + i*12
|
|
if p+12 > len(tiff) {
|
|
break
|
|
}
|
|
tag := bo.Uint16(tiff[p : p+2])
|
|
typ := bo.Uint16(tiff[p+2 : p+4])
|
|
count := int(bo.Uint32(tiff[p+4 : p+8]))
|
|
valRaw := tiff[p+8 : p+12]
|
|
// Sub-IFD pointers never appear as regular entries in the output.
|
|
if ptrs != nil {
|
|
switch tag {
|
|
case 0x8769: // Exif SubIFD pointer
|
|
ptrs.exif = int(bo.Uint32(valRaw))
|
|
continue
|
|
case 0x8825: // GPS IFD pointer
|
|
ptrs.gps = int(bo.Uint32(valRaw))
|
|
continue
|
|
case 0xa005: // Interoperability IFD pointer
|
|
ptrs.interop = int(bo.Uint32(valRaw))
|
|
continue
|
|
}
|
|
}
|
|
e := MetaEntry{Kind: name, Keyword: exifTagName(tag, name)}
|
|
if tag == 0x927c { // MakerNote
|
|
e.Value = fmt.Sprintf("%d bytes (vendor-specific, not decoded)", count)
|
|
out = append(out, e)
|
|
continue
|
|
}
|
|
e.Value = readEXIFValue(tiff, bo, typ, count, valRaw)
|
|
out = append(out, e)
|
|
}
|
|
// "Next IFD" pointer follows the directory entries (4 bytes).
|
|
if nextPtr != nil {
|
|
tail := base + n*12
|
|
if tail+4 <= len(tiff) {
|
|
*nextPtr = int(bo.Uint32(tiff[tail : tail+4]))
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func readEXIFValue(tiff []byte, bo binary.ByteOrder, typ uint16, count int, valRaw []byte) string {
|
|
typeSize := map[uint16]int{1: 1, 2: 1, 3: 2, 4: 4, 5: 8, 7: 1, 9: 4, 10: 8}
|
|
sz, ok := typeSize[typ]
|
|
if !ok {
|
|
return fmt.Sprintf("type=%d count=%d", typ, count)
|
|
}
|
|
total := sz * count
|
|
var data []byte
|
|
if total <= 4 {
|
|
data = valRaw[:total]
|
|
} else {
|
|
off := int(bo.Uint32(valRaw))
|
|
if off < 0 || off+total > len(tiff) {
|
|
return fmt.Sprintf("type=%d count=%d (oob)", typ, count)
|
|
}
|
|
data = tiff[off : off+total]
|
|
}
|
|
switch typ {
|
|
case 2: // ASCII (null-terminated)
|
|
return safeText(bytes.TrimRight(data, "\x00"))
|
|
case 1, 7: // BYTE, UNDEFINED — show as hex preview
|
|
if len(data) > 32 {
|
|
return fmt.Sprintf("%x… (%d bytes)", data[:32], len(data))
|
|
}
|
|
return fmt.Sprintf("%x", data)
|
|
case 3: // SHORT
|
|
parts := []string{}
|
|
for i := 0; i < count && i < 8; i++ {
|
|
parts = append(parts, fmt.Sprintf("%d", bo.Uint16(data[i*2:i*2+2])))
|
|
}
|
|
if count > 8 {
|
|
parts = append(parts, "…")
|
|
}
|
|
return strings.Join(parts, ", ")
|
|
case 4: // LONG
|
|
parts := []string{}
|
|
for i := 0; i < count && i < 6; i++ {
|
|
parts = append(parts, fmt.Sprintf("%d", bo.Uint32(data[i*4:i*4+4])))
|
|
}
|
|
if count > 6 {
|
|
parts = append(parts, "…")
|
|
}
|
|
return strings.Join(parts, ", ")
|
|
case 5, 10: // RATIONAL / SRATIONAL
|
|
parts := []string{}
|
|
for i := 0; i < count && i < 4; i++ {
|
|
n := bo.Uint32(data[i*8 : i*8+4])
|
|
dn := bo.Uint32(data[i*8+4 : i*8+8])
|
|
if dn == 0 {
|
|
parts = append(parts, fmt.Sprintf("%d/0", n))
|
|
} else {
|
|
parts = append(parts, fmt.Sprintf("%d/%d", n, dn))
|
|
}
|
|
}
|
|
return strings.Join(parts, ", ")
|
|
case 9: // SLONG
|
|
parts := []string{}
|
|
for i := 0; i < count && i < 6; i++ {
|
|
parts = append(parts, fmt.Sprintf("%d", int32(bo.Uint32(data[i*4:i*4+4]))))
|
|
}
|
|
return strings.Join(parts, ", ")
|
|
}
|
|
return fmt.Sprintf("type=%d count=%d", typ, count)
|
|
}
|
|
|
|
func exifTagName(tag uint16, ifd string) string {
|
|
if ifd == "GPSIFD" {
|
|
if n, ok := gpsTags[tag]; ok {
|
|
return n
|
|
}
|
|
return fmt.Sprintf("GPS tag 0x%04x", tag)
|
|
}
|
|
if n, ok := exifTags[tag]; ok {
|
|
return n
|
|
}
|
|
return fmt.Sprintf("tag 0x%04x", tag)
|
|
}
|
|
|
|
// exifTags covers the standard TIFF/Exif tags routinely seen in
|
|
// JPEG/TIFF images produced by consumer cameras and phones.
|
|
var exifTags = map[uint16]string{
|
|
// TIFF / IFD0
|
|
0x0100: "ImageWidth", 0x0101: "ImageLength",
|
|
0x0102: "BitsPerSample", 0x0103: "Compression",
|
|
0x0106: "PhotometricInterpretation", 0x010a: "FillOrder",
|
|
0x010d: "DocumentName", 0x010e: "ImageDescription",
|
|
0x010f: "Make", 0x0110: "Model", 0x0111: "StripOffsets",
|
|
0x0112: "Orientation", 0x0115: "SamplesPerPixel",
|
|
0x0116: "RowsPerStrip", 0x0117: "StripByteCounts",
|
|
0x011a: "XResolution", 0x011b: "YResolution",
|
|
0x011c: "PlanarConfiguration", 0x0128: "ResolutionUnit",
|
|
0x012d: "TransferFunction", 0x0131: "Software", 0x0132: "DateTime",
|
|
0x013b: "Artist", 0x013c: "HostComputer",
|
|
0x013e: "WhitePoint", 0x013f: "PrimaryChromaticities",
|
|
0x0211: "YCbCrCoefficients", 0x0212: "YCbCrSubSampling",
|
|
0x0213: "YCbCrPositioning", 0x0214: "ReferenceBlackWhite",
|
|
0x02bc: "XMP",
|
|
0x8298: "Copyright", 0x83bb: "IPTCNAA",
|
|
0x8769: "ExifIFDPointer", 0x8773: "InterColorProfile",
|
|
0x8825: "GPSIFDPointer",
|
|
// Exif SubIFD
|
|
0x829a: "ExposureTime", 0x829d: "FNumber",
|
|
0x8822: "ExposureProgram", 0x8824: "SpectralSensitivity",
|
|
0x8827: "ISOSpeedRatings", 0x8828: "OECF",
|
|
0x9000: "ExifVersion",
|
|
0x9003: "DateTimeOriginal", 0x9004: "DateTimeDigitized",
|
|
0x9010: "OffsetTime", 0x9011: "OffsetTimeOriginal", 0x9012: "OffsetTimeDigitized",
|
|
0x9101: "ComponentsConfiguration", 0x9102: "CompressedBitsPerPixel",
|
|
0x9201: "ShutterSpeedValue", 0x9202: "ApertureValue",
|
|
0x9203: "BrightnessValue", 0x9204: "ExposureBiasValue",
|
|
0x9205: "MaxApertureValue", 0x9206: "SubjectDistance",
|
|
0x9207: "MeteringMode", 0x9208: "LightSource", 0x9209: "Flash",
|
|
0x920a: "FocalLength",
|
|
0x9214: "SubjectArea", 0x927c: "MakerNote", 0x9286: "UserComment",
|
|
0x9290: "SubSecTime", 0x9291: "SubSecTimeOriginal", 0x9292: "SubSecTimeDigitized",
|
|
0xa000: "FlashpixVersion", 0xa001: "ColorSpace",
|
|
0xa002: "PixelXDimension", 0xa003: "PixelYDimension",
|
|
0xa004: "RelatedSoundFile", 0xa005: "InteropIFDPointer",
|
|
0xa20b: "FlashEnergy", 0xa20c: "SpatialFrequencyResponse",
|
|
0xa20e: "FocalPlaneXResolution", 0xa20f: "FocalPlaneYResolution",
|
|
0xa210: "FocalPlaneResolutionUnit",
|
|
0xa214: "SubjectLocation", 0xa215: "ExposureIndex",
|
|
0xa217: "SensingMethod", 0xa300: "FileSource", 0xa301: "SceneType",
|
|
0xa302: "CFAPattern", 0xa401: "CustomRendered",
|
|
0xa402: "ExposureMode", 0xa403: "WhiteBalance",
|
|
0xa404: "DigitalZoomRatio", 0xa405: "FocalLengthIn35mmFilm",
|
|
0xa406: "SceneCaptureType", 0xa407: "GainControl",
|
|
0xa408: "Contrast", 0xa409: "Saturation", 0xa40a: "Sharpness",
|
|
0xa40b: "DeviceSettingDescription", 0xa40c: "SubjectDistanceRange",
|
|
0xa420: "ImageUniqueID", 0xa430: "OwnerName", 0xa431: "SerialNumber",
|
|
0xa432: "LensSpecification", 0xa433: "LensMake", 0xa434: "LensModel",
|
|
0xa435: "LensSerialNumber",
|
|
// Thumbnail IFD1 re-uses IFD0 tags; additional ones:
|
|
0x0201: "JPEGInterchangeFormat", 0x0202: "JPEGInterchangeFormatLength",
|
|
}
|
|
|
|
var gpsTags = map[uint16]string{
|
|
0x0000: "GPSVersionID", 0x0001: "GPSLatitudeRef", 0x0002: "GPSLatitude",
|
|
0x0003: "GPSLongitudeRef", 0x0004: "GPSLongitude",
|
|
0x0005: "GPSAltitudeRef", 0x0006: "GPSAltitude",
|
|
0x0007: "GPSTimeStamp", 0x0008: "GPSSatellites", 0x0009: "GPSStatus",
|
|
0x000a: "GPSMeasureMode", 0x000b: "GPSDOP", 0x000c: "GPSSpeedRef",
|
|
0x000d: "GPSSpeed", 0x000e: "GPSTrackRef", 0x000f: "GPSTrack",
|
|
0x0010: "GPSImgDirectionRef", 0x0011: "GPSImgDirection",
|
|
0x0012: "GPSMapDatum", 0x0013: "GPSDestLatitudeRef", 0x0014: "GPSDestLatitude",
|
|
0x0015: "GPSDestLongitudeRef", 0x0016: "GPSDestLongitude",
|
|
0x0017: "GPSDestBearingRef", 0x0018: "GPSDestBearing",
|
|
0x0019: "GPSDestDistanceRef", 0x001a: "GPSDestDistance",
|
|
0x001b: "GPSProcessingMethod", 0x001c: "GPSAreaInformation",
|
|
0x001d: "GPSDateStamp", 0x001e: "GPSDifferential", 0x001f: "GPSHPositioningError",
|
|
}
|
|
|
|
func zlibDecompress(b []byte) ([]byte, error) {
|
|
r, err := zlib.NewReader(bytes.NewReader(b))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer r.Close()
|
|
// 2 MiB cap — textual metadata should never be near this.
|
|
lim := &io.LimitedReader{R: r, N: 2 * 1024 * 1024}
|
|
return io.ReadAll(lim)
|
|
}
|
|
|
|
func safeText(b []byte) string {
|
|
// Preserve text but trim extreme size and strip control chars other than tab/newline.
|
|
if len(b) > 4096 {
|
|
b = b[:4096]
|
|
}
|
|
sb := strings.Builder{}
|
|
sb.Grow(len(b))
|
|
for _, c := range b {
|
|
if c == '\t' || c == '\n' || c == '\r' || (c >= 0x20 && c <= 0x7e) {
|
|
sb.WriteByte(c)
|
|
continue
|
|
}
|
|
if c >= 0x80 {
|
|
// Pass through; browser will render as UTF-8 if valid.
|
|
sb.WriteByte(c)
|
|
continue
|
|
}
|
|
// Drop other controls.
|
|
}
|
|
return sb.String()
|
|
}
|
|
|
|
func minInt64(a, b int64) int64 {
|
|
if a < b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
// scanGIFMeta walks a GIF file and surfaces every extension block that
|
|
// can carry human-readable data: Comment (0x21 0xFE), Plain Text
|
|
// (0x21 0x01), and Application (0x21 0xFF — XMP, Netscape loop, etc.).
|
|
func scanGIFMeta(d *document.Document) ([]MetaEntry, error) {
|
|
size := d.Size()
|
|
out := []MetaEntry{}
|
|
// Skip header (6) + logical screen descriptor (7 fixed) and the
|
|
// optional global colour table.
|
|
hdr, err := d.Range(0, 13)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
off := int64(13)
|
|
packed := hdr[10]
|
|
if packed&0x80 != 0 {
|
|
gctSize := int64(3) * (int64(1) << uint((packed&0x07)+1))
|
|
off += gctSize
|
|
}
|
|
for off < size {
|
|
b, err := d.Range(off, 1)
|
|
if err != nil {
|
|
break
|
|
}
|
|
switch b[0] {
|
|
case 0x3b: // trailer
|
|
return out, nil
|
|
case 0x2c: // Image Descriptor: skip descriptor + optional LCT + LZW data
|
|
next, ok := skipGIFImage(d, off)
|
|
if !ok {
|
|
return out, nil
|
|
}
|
|
off = next
|
|
case 0x21: // Extension Introducer
|
|
if off+2 > size {
|
|
return out, nil
|
|
}
|
|
lbl, _ := d.Range(off+1, 1)
|
|
start := off
|
|
payload, next, ok := readGIFSubBlocks(d, off+2)
|
|
if !ok {
|
|
return out, nil
|
|
}
|
|
switch lbl[0] {
|
|
case 0xfe:
|
|
out = append(out, MetaEntry{
|
|
Offset: start, Length: next - start,
|
|
Container: "gif", Kind: "Comment",
|
|
Value: safeText(payload),
|
|
})
|
|
case 0x01:
|
|
// Plain Text: first 12 bytes are text-grid parameters.
|
|
text := payload
|
|
if len(text) > 12 {
|
|
text = text[12:]
|
|
} else {
|
|
text = nil
|
|
}
|
|
out = append(out, MetaEntry{
|
|
Offset: start, Length: next - start,
|
|
Container: "gif", Kind: "PlainText",
|
|
Value: safeText(text),
|
|
})
|
|
case 0xff:
|
|
// Application Extension: first sub-block is an 11-byte
|
|
// identifier like "NETSCAPE2.0" or "XMP DataXMP".
|
|
if len(payload) >= 11 {
|
|
appID := string(bytes.TrimRight(payload[:11], "\x00 "))
|
|
rest := payload[11:]
|
|
out = append(out, MetaEntry{
|
|
Offset: start, Length: next - start,
|
|
Container: "gif", Kind: "Application",
|
|
Keyword: appID,
|
|
Value: safeText(rest),
|
|
})
|
|
} else {
|
|
out = append(out, MetaEntry{
|
|
Offset: start, Length: next - start,
|
|
Container: "gif", Kind: "Application",
|
|
Value: safeText(payload),
|
|
})
|
|
}
|
|
default:
|
|
// Graphic control (0xf9) and others — skip.
|
|
}
|
|
off = next
|
|
default:
|
|
// Unknown byte; bail.
|
|
return out, nil
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// readGIFSubBlocks reads a chain of GIF sub-blocks: each starts with a
|
|
// length byte (0 terminates). Returns (concatenated payload, offset of
|
|
// next byte after terminator, ok).
|
|
func readGIFSubBlocks(d *document.Document, off int64) ([]byte, int64, bool) {
|
|
size := d.Size()
|
|
out := []byte{}
|
|
for off < size {
|
|
ln, err := d.Range(off, 1)
|
|
if err != nil {
|
|
return nil, off, false
|
|
}
|
|
n := int64(ln[0])
|
|
off++
|
|
if n == 0 {
|
|
return out, off, true
|
|
}
|
|
if off+n > size {
|
|
return nil, off, false
|
|
}
|
|
block, err := d.Range(off, n)
|
|
if err != nil {
|
|
return nil, off, false
|
|
}
|
|
out = append(out, block...)
|
|
off += n
|
|
// Hard cap to prevent OOM on malformed input.
|
|
if len(out) > 16*1024*1024 {
|
|
return out, off, true
|
|
}
|
|
}
|
|
return nil, off, false
|
|
}
|
|
|
|
// skipGIFImage walks an Image Descriptor block starting at off (the 0x2c
|
|
// byte), skipping the descriptor, any local colour table, the LZW
|
|
// minimum-code-size byte and the image data sub-blocks. Returns the
|
|
// offset of the next block, or (0, false) on truncation.
|
|
func skipGIFImage(d *document.Document, off int64) (int64, bool) {
|
|
size := d.Size()
|
|
if off+10 > size {
|
|
return 0, false
|
|
}
|
|
desc, err := d.Range(off, 10)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
packed := desc[9]
|
|
off += 10
|
|
if packed&0x80 != 0 {
|
|
lctSize := int64(3) * (int64(1) << uint((packed&0x07)+1))
|
|
off += lctSize
|
|
}
|
|
// LZW minimum code size byte, then sub-blocks.
|
|
if off+1 > size {
|
|
return 0, false
|
|
}
|
|
off++
|
|
_, next, ok := readGIFSubBlocks(d, off)
|
|
if !ok {
|
|
return 0, false
|
|
}
|
|
return next, true
|
|
}
|