Files
mtusi2026lab4/internal/imagecheck/imagecheck.go
T

366 lines
8.4 KiB
Go

// Package imagecheck validates PNG and JPEG structure without decoding the
// raster. A full decode of a 40-megapixel image would allocate hundreds of
// megabytes; attachment uploads must stay bounded. The parser verifies chunk
// CRCs and the JPEG marker/scan structure, which catches truncation and
// corruption while using constant memory.
package imagecheck
import (
"bufio"
"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
)
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 err := checkCriticalChunk(chunkType, seen); err != nil {
return Info{}, err
}
data, err := readChunkData(reader, checksum, length)
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]))
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)
}
case "IDAT":
hasIDAT = 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 _, err := io.Copy(io.Discard, reader); err != nil {
return Info{}, corrupt("png trailing data", err)
}
return info, nil
}
}
}
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) ([]byte, error) {
if length <= 64<<10 {
data := make([]byte, length)
if _, err := io.ReadFull(reader, data); err != nil {
return nil, err
}
_, _ = checksum.Write(data)
return data, nil
}
if _, err := io.CopyN(checksum, 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...))
}