Files
mtusi2026lab5/internal/imagecheck/imagecheck.go
T
Vladislav Kunetskiy 01b885e846 lab5: очереди и асинхронная обработка изображений
Durable staging handoff, transactional outbox, at-least-once worker with lease fencing, idempotent versioned pipeline, three variants, operator tooling, contract tests and evidence. Includes the review fixes: reprocess source selection and failure settlement, replay guards, stale-job retirement, PNG structural/raster validation, migration rollback safety and audit events.
2026-10-31 14:34:24 +03:00

669 lines
16 KiB
Go

// Package imagecheck validates PNG and JPEG structure without decoding the
// raster into an image. A full decode of a 40-megapixel image would allocate
// hundreds of megabytes; attachment uploads must stay bounded. For PNG the
// parser verifies chunk CRCs and streams the zlib image data to check exact
// scanline sizes and filter types without keeping the raster in memory. The
// JPEG parser verifies marker/scan structure. Both catch truncation and
// corruption while using bounded memory.
package imagecheck
import (
"bufio"
"bytes"
"compress/zlib"
"encoding/binary"
"errors"
"fmt"
"hash/crc32"
"io"
"os"
)
var (
ErrUnsupported = errors.New("unsupported image format")
ErrCorrupt = errors.New("corrupt image")
ErrTooLarge = errors.New("image has too many pixels")
)
const (
pngSignature = "\x89PNG\r\n\x1a\n"
maxChunkSize = 1 << 30
)
// Info is the validated header. ContentType is one of image/png or image/jpeg.
type Info struct {
ContentType string
Width int64
Height int64
}
func ValidateFile(path string, maxPixels int64) (Info, error) {
file, err := os.Open(path)
if err != nil {
return Info{}, fmt.Errorf("open upload: %w", err)
}
defer func() { _ = file.Close() }()
return Validate(file, maxPixels)
}
// Validate consumes the reader to EOF (so a caller hashing the stream gets all
// bytes) and returns the detected format and dimensions.
func Validate(r io.Reader, maxPixels int64) (Info, error) {
reader := bufio.NewReaderSize(r, 64<<10)
header, err := reader.Peek(8)
if err != nil {
if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
return Info{}, fmt.Errorf("%w: image is empty or truncated", ErrUnsupported)
}
return Info{}, err
}
switch {
case string(header[:8]) == pngSignature:
return validatePNG(reader, maxPixels)
case header[0] == 0xFF && header[1] == 0xD8 && header[2] == 0xFF:
return validateJPEG(reader, maxPixels)
default:
return Info{}, fmt.Errorf("%w: unrecognised signature", ErrUnsupported)
}
}
func validatePNG(reader *bufio.Reader, maxPixels int64) (Info, error) {
if _, err := reader.Discard(len(pngSignature)); err != nil {
return Info{}, corrupt("png signature", err)
}
var (
info Info
seen = make(map[string]bool, 4)
first = true
hasIDAT bool
paletteReady bool
trnsSeen bool
colorType byte
bitDepth byte
paletteEntries int
idat bytes.Buffer
raster []pngPass
rasterBytes int64
maxIDAT int64 = -1
lastChunk string
)
info.ContentType = "image/png"
for {
var lengthBytes [4]byte
if _, err := io.ReadFull(reader, lengthBytes[:]); err != nil {
return Info{}, corrupt("png chunk length", err)
}
length := int64(binary.BigEndian.Uint32(lengthBytes[:]))
if length < 0 || length > maxChunkSize {
return Info{}, corruptf("png chunk length %d", length)
}
var typeBytes [4]byte
if _, err := io.ReadFull(reader, typeBytes[:]); err != nil {
return Info{}, corrupt("png chunk type", err)
}
chunkType := string(typeBytes[:])
checksum := crc32.NewIEEE()
_, _ = checksum.Write(typeBytes[:])
if first && chunkType != "IHDR" {
return Info{}, corruptf("png first chunk is %q, want IHDR", chunkType)
}
first = false
if seen[chunkType] && (chunkType == "IHDR" || chunkType == "PLTE" || chunkType == "IEND") {
return Info{}, corruptf("png duplicate %s chunk", chunkType)
}
if chunkType == "PLTE" && hasIDAT {
return Info{}, corruptf("png PLTE chunk after IDAT")
}
if chunkType == "IDAT" && seen["IDAT"] && lastChunk != "IDAT" {
return Info{}, corruptf("png IDAT chunks must be consecutive")
}
if err := checkCriticalChunk(chunkType, seen); err != nil {
return Info{}, err
}
var chunkSink io.Writer
if chunkType == "IDAT" {
if maxIDAT >= 0 && int64(idat.Len())+length > maxIDAT {
return Info{}, corruptf("png idat compressed data exceeds %d bytes", maxIDAT)
}
chunkSink = &idat
}
data, err := readChunkData(reader, checksum, length, chunkSink)
if err != nil {
return Info{}, corrupt("png chunk data", err)
}
var crcBytes [4]byte
if _, err := io.ReadFull(reader, crcBytes[:]); err != nil {
return Info{}, corrupt("png chunk crc", err)
}
if binary.BigEndian.Uint32(crcBytes[:]) != checksum.Sum32() {
return Info{}, corruptf("png chunk %q crc mismatch", chunkType)
}
switch chunkType {
case "IHDR":
if length != 13 {
return Info{}, corruptf("png IHDR length %d", length)
}
info.Width = int64(binary.BigEndian.Uint32(data[0:4]))
info.Height = int64(binary.BigEndian.Uint32(data[4:8]))
colorType = data[9]
bitDepth = data[8]
if info.Width <= 0 || info.Height <= 0 {
return Info{}, corruptf("png dimensions %dx%d", info.Width, info.Height)
}
// Short-circuit before multiplying: a malicious IHDR can contain
// 32-bit dimensions whose product overflows int64.
if maxPixels > 0 && (info.Width > maxPixels || info.Height > maxPixels || info.Width*info.Height > maxPixels) {
return Info{}, fmt.Errorf("%w: %dx%d", ErrTooLarge, info.Width, info.Height)
}
bound, err := pngRasterLayout(info, data[8], data[9], data[10], data[11], data[12])
if err != nil {
return Info{}, err
}
raster = bound
rasterBytes = pngRasterBytes(bound)
if rasterBytes <= 1<<40 {
// zlib overhead: ~5 bytes per 16 KiB block, 2-byte header and
// a 4-byte Adler trailer. The 1 MiB constant covers tiny
// images where the relative term vanishes.
maxIDAT = rasterBytes + rasterBytes/256 + 1<<20
}
case "IDAT":
hasIDAT = true
case "PLTE":
if colorType == 0 || colorType == 4 {
return Info{}, corruptf("png PLTE is invalid for color type %d", colorType)
}
if length == 0 || length%3 != 0 || length > 3*256 {
return Info{}, corruptf("png PLTE length %d", length)
}
if length/3 > 1<<bitDepth {
return Info{}, corruptf(
"png PLTE has %d entries for bit depth %d", length/3, bitDepth,
)
}
if trnsSeen {
return Info{}, corruptf("png PLTE chunk after tRNS")
}
paletteEntries = int(length / 3)
if !hasIDAT {
paletteReady = true
}
case "tRNS":
if trnsSeen {
return Info{}, corruptf("png duplicate tRNS chunk")
}
if hasIDAT {
return Info{}, corruptf("png tRNS chunk after IDAT")
}
switch colorType {
case 0:
if length != 2 {
return Info{}, corruptf("png tRNS length %d for color type 0", length)
}
case 2:
if length != 6 {
return Info{}, corruptf("png tRNS length %d for color type 2", length)
}
case 3:
if !paletteReady {
return Info{}, corruptf("png tRNS before PLTE")
}
if length > 256 {
return Info{}, corruptf("png tRNS length %d", length)
}
if int(length) > paletteEntries {
return Info{}, corruptf(
"png tRNS length %d exceeds %d palette entries",
length, paletteEntries,
)
}
default:
return Info{}, corruptf("png tRNS invalid for color type %d", colorType)
}
trnsSeen = true
case "IEND":
if length != 0 {
return Info{}, corruptf("png IEND length %d", length)
}
if !hasIDAT {
return Info{}, corruptf("png has no IDAT chunk")
}
if colorType == 3 && !paletteReady {
return Info{}, corruptf("png palette image has no PLTE before IDAT")
}
// The chunk walker proves structure, but a stream whose bytes
// merely look like a chunk layout (valid length/type/CRC) may
// still not be a PNG raster: the zlib payload must inflate to
// exactly the IHDR-declared scanlines with valid filter bytes.
if err := validateRaster(idat.Bytes(), raster); err != nil {
return Info{}, err
}
if _, err := io.Copy(io.Discard, reader); err != nil {
return Info{}, corrupt("png trailing data", err)
}
return info, nil
}
lastChunk = chunkType
}
}
// pngPass is one consecutive block of scanlines in the inflated image stream.
// Non-interlaced PNGs have a single pass; Adam7 has up to seven.
type pngPass struct {
rowBytes int64
rows int64
}
type pngPassSpec struct {
x0, y0 int64
dx, dy int64
}
var adam7Passes = []pngPassSpec{
{x0: 0, y0: 0, dx: 8, dy: 8},
{x0: 4, y0: 0, dx: 8, dy: 8},
{x0: 0, y0: 4, dx: 4, dy: 8},
{x0: 2, y0: 0, dx: 4, dy: 4},
{x0: 0, y0: 2, dx: 2, dy: 4},
{x0: 1, y0: 0, dx: 2, dy: 2},
{x0: 0, y0: 1, dx: 1, dy: 2},
}
// pngRasterLayout returns the exact inflated size and row layout for the
// IHDR. The Adam7 layout matters: a single non-interlaced formula either
// rejects valid interlaced images or accepts oversized streams.
func pngRasterLayout(
info Info,
bitDepth, colorType, compression, filter, interlace byte,
) ([]pngPass, error) {
if compression != 0 || filter != 0 {
return nil, corruptf(
"png compression/filter method %d/%d", compression, filter,
)
}
var bitsPerPixel int64
switch colorType {
case 0: // grayscale
if bitDepth != 1 && bitDepth != 2 && bitDepth != 4 && bitDepth != 8 && bitDepth != 16 {
return nil, corruptf("png invalid bit depth %d for color type 0", bitDepth)
}
bitsPerPixel = int64(bitDepth)
case 2: // truecolor
if bitDepth != 8 && bitDepth != 16 {
return nil, corruptf("png invalid bit depth %d for color type 2", bitDepth)
}
bitsPerPixel = 3 * int64(bitDepth)
case 3: // palette
if bitDepth != 1 && bitDepth != 2 && bitDepth != 4 && bitDepth != 8 {
return nil, corruptf("png invalid bit depth %d for color type 3", bitDepth)
}
bitsPerPixel = int64(bitDepth)
case 4: // grayscale + alpha
if bitDepth != 8 && bitDepth != 16 {
return nil, corruptf("png invalid bit depth %d for color type 4", bitDepth)
}
bitsPerPixel = 2 * int64(bitDepth)
case 6: // RGBA
if bitDepth != 8 && bitDepth != 16 {
return nil, corruptf("png invalid bit depth %d for color type 6", bitDepth)
}
bitsPerPixel = 4 * int64(bitDepth)
default:
return nil, corruptf("png invalid color type %d", colorType)
}
specs := []pngPassSpec{{x0: 0, y0: 0, dx: 1, dy: 1}}
switch interlace {
case 0:
case 1:
specs = adam7Passes
default:
return nil, corruptf("png invalid interlace method %d", interlace)
}
passes := make([]pngPass, 0, len(specs))
for _, spec := range specs {
if info.Width <= spec.x0 || info.Height <= spec.y0 {
continue
}
width := (info.Width - spec.x0 + spec.dx - 1) / spec.dx
rows := (info.Height - spec.y0 + spec.dy - 1) / spec.dy
rowBytes := (width*bitsPerPixel + 7) / 8
// Keep the total overflow-safe. Valid PNGs are additionally bounded
// by the pixel limit checked by the caller.
if rowBytes+1 > (1<<62)/rows {
return nil, fmt.Errorf("%w: png dimensions overflow", ErrTooLarge)
}
passes = append(passes, pngPass{rowBytes: rowBytes, rows: rows})
}
return passes, nil
}
func pngRasterBytes(passes []pngPass) int64 {
var total int64
for _, pass := range passes {
row := (pass.rowBytes + 1) * pass.rows
if total > (1<<62)-row {
return 1<<62 - 1
}
total += row
}
return total
}
// validateRaster streams the inflated image data, checking every scanline
// filter byte and requiring exactly the IHDR-declared number of rows. It
// catches zlib streams that decompress cleanly but do not describe a valid
// raster (empty payloads, bogus filter bytes) and rejects extra data as a
// decompression bomb.
func validateRaster(compressed []byte, passes []pngPass) error {
source := bytes.NewReader(compressed)
reader, err := zlib.NewReader(source)
if err != nil {
return corrupt("png idat zlib header", err)
}
for _, pass := range passes {
for range pass.rows {
var filter [1]byte
if _, err := io.ReadFull(reader, filter[:]); err != nil {
return corrupt("png scanline filter", err)
}
if filter[0] > 4 {
return corruptf("png invalid scanline filter %d", filter[0])
}
if _, err := io.CopyN(io.Discard, reader, pass.rowBytes); err != nil {
return corrupt("png scanline data", err)
}
}
}
var extra [1]byte
switch _, err := io.ReadFull(reader, extra[:]); {
case errors.Is(err, io.EOF):
// A clean zlib EOF also verifies the Adler-32 trailer. bytes.Reader
// satisfies io.ByteReader, so the inflater consumes exactly the zlib
// stream; anything left is data after the stream, which PNG forbids.
if source.Len() != 0 {
return corruptf("png idat has %d trailing bytes", source.Len())
}
return nil
case err == nil:
return fmt.Errorf("%w: png raster exceeds declared dimensions", ErrTooLarge)
default:
return corrupt("png idat zlib trailer", err)
}
}
func checkCriticalChunk(chunkType string, seen map[string]bool) error {
if chunkType == "IHDR" || chunkType == "PLTE" || chunkType == "IDAT" || chunkType == "IEND" {
seen[chunkType] = true
return nil
}
if chunkType[0] >= 'A' && chunkType[0] <= 'Z' {
return corruptf("png unknown critical chunk %q", chunkType)
}
return nil
}
func readChunkData(reader io.Reader, checksum io.Writer, length int64, sink io.Writer) ([]byte, error) {
if length <= 64<<10 {
data := make([]byte, length)
if _, err := io.ReadFull(reader, data); err != nil {
return nil, err
}
_, _ = checksum.Write(data)
if sink != nil {
_, _ = sink.Write(data)
}
return data, nil
}
destination := checksum
if sink != nil {
destination = io.MultiWriter(checksum, sink)
}
if _, err := io.CopyN(destination, reader, length); err != nil {
return nil, err
}
return nil, nil
}
func validateJPEG(reader *bufio.Reader, maxPixels int64) (Info, error) {
if _, err := reader.Discard(2); err != nil {
return Info{}, corrupt("jpeg SOI", err)
}
var (
info Info
hasSOF bool
hasSOS bool
pending byte
markerErr error
)
info.ContentType = "image/jpeg"
for {
marker := pending
pending = 0
if marker == 0 {
marker, markerErr = nextMarker(reader)
if markerErr != nil {
return Info{}, corrupt("jpeg marker", markerErr)
}
}
switch {
case marker == 0xD9: // EOI
if !hasSOF || !hasSOS {
return Info{}, corruptf("jpeg missing SOF or SOS")
}
if _, err := io.Copy(io.Discard, reader); err != nil {
return Info{}, corrupt("jpeg trailing data", err)
}
return info, nil
case isStandalone(marker):
continue
}
length, err := readUint16(reader)
if err != nil {
return Info{}, corrupt("jpeg segment length", err)
}
if length < 2 {
return Info{}, corruptf("jpeg segment %02x length %d", marker, length)
}
data := make([]byte, int(length)-2)
if _, err := io.ReadFull(reader, data); err != nil {
return Info{}, corrupt("jpeg segment data", err)
}
switch {
case isSOF(marker):
if len(data) < 5 {
return Info{}, corruptf("jpeg SOF %02x is too short", marker)
}
info.Height = int64(binary.BigEndian.Uint16(data[1:3]))
info.Width = int64(binary.BigEndian.Uint16(data[3:5]))
if info.Width <= 0 || info.Height <= 0 {
return Info{}, corruptf("jpeg dimensions %dx%d", info.Width, info.Height)
}
hasSOF = true
if maxPixels > 0 && info.Width*info.Height > maxPixels {
return Info{}, fmt.Errorf("%w: %dx%d", ErrTooLarge, info.Width, info.Height)
}
case marker == 0xDA: // SOS
hasSOS = true
next, err := scanEntropy(reader)
if err != nil {
return Info{}, corrupt("jpeg scan", err)
}
pending = next
}
}
}
func nextMarker(reader *bufio.Reader) (byte, error) {
for {
value, err := reader.ReadByte()
if err != nil {
return 0, err
}
if value != 0xFF {
return 0, fmt.Errorf("unexpected byte %02x before marker", value)
}
value, err = reader.ReadByte()
if err != nil {
return 0, err
}
if value == 0xFF {
continue
}
return value, nil
}
}
// scanEntropy consumes entropy-coded data after SOS and returns the next
// non-RST marker (0xFF prefix consumed).
func scanEntropy(reader *bufio.Reader) (byte, error) {
for {
value, err := reader.ReadByte()
if err != nil {
return 0, err
}
if value != 0xFF {
continue
}
value, err = reader.ReadByte()
if err != nil {
return 0, err
}
switch {
case value == 0x00:
continue
case value >= 0xD0 && value <= 0xD7:
continue
default:
return value, nil
}
}
}
func readUint16(reader io.Reader) (uint16, error) {
var raw [2]byte
if _, err := io.ReadFull(reader, raw[:]); err != nil {
return 0, err
}
return binary.BigEndian.Uint16(raw[:]), nil
}
func isSOF(marker byte) bool {
switch marker {
case 0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF:
return true
default:
return false
}
}
func isStandalone(marker byte) bool {
return marker == 0x01 || (marker >= 0xD0 && marker <= 0xD7)
}
func corrupt(context string, err error) error {
return fmt.Errorf("%w: %s: %w", ErrCorrupt, context, err)
}
func corruptf(format string, args ...any) error {
return fmt.Errorf("%w: %s", ErrCorrupt, fmt.Sprintf(format, args...))
}