Files
mtusi2026lab6/internal/imagecheck/imagecheck.go
T

593 lines
17 KiB
Go

// Package imagecheck потоково проверяет PNG/JPEG без декодирования пикселей.
//
// Проверка идёт по мере чтения (используется параллельно с PUT в S3), память
// O(1) от размера изображения: размеры берутся из заголовка (IHDR/SOF) и
// сравниваются с лимитом до чтения тела; PNG — CRC каждого chunk, длина
// распакованного IDAT-потока (zlib → io.Discard) и байт фильтра каждой строки,
// JPEG — структура сегментов и маркер EOI. «Заведомо повреждённые» файлы
// (обрыв, битый CRC, мусор вместо данных, чужой формат) дают ErrInvalid,
// слишком большие по пикселям — ErrTooLarge.
package imagecheck
import (
"bufio"
"bytes"
"compress/zlib"
"encoding/binary"
"errors"
"fmt"
"hash/crc32"
"io"
)
const (
PNG = "image/png"
JPEG = "image/jpeg"
)
var (
ErrInvalid = errors.New("invalid or unsupported image")
ErrTooLarge = errors.New("image dimensions exceed limit")
)
var pngSignature = []byte("\x89PNG\r\n\x1a\n")
// Sniff определяет формат по первым байтам (не по заголовку Content-Type клиента).
func Sniff(head []byte) (string, bool) {
switch {
case bytes.HasPrefix(head, pngSignature):
return PNG, true
case len(head) >= 3 && head[0] == 0xFF && head[1] == 0xD8 && head[2] == 0xFF:
return JPEG, true
}
return "", false
}
// Result — что удалось узнать при проверке.
type Result struct {
Format string
Width int
Height int
}
// Validate читает r до конца и проверяет изображение формата format.
// maxPixels ограничивает width*height. Хвост после конца изображения
// дочитывается и игнорируется, чтобы не блокировать писателя.
func Validate(r io.Reader, format string, maxPixels int64) (Result, error) {
br := bufio.NewReaderSize(r, 32*1024)
var res Result
var err error
switch format {
case PNG:
res, err = validatePNG(br, maxPixels)
case JPEG:
res, err = validateJPEG(br, maxPixels)
default:
return Result{}, ErrInvalid
}
if err != nil {
return res, err
}
_, _ = io.Copy(io.Discard, br)
return res, nil
}
func invalid(format string, args ...any) error {
return fmt.Errorf("%w: %s", ErrInvalid, fmt.Sprintf(format, args...))
}
// --- PNG ---
func channels(colorType byte) (int, bool) {
switch colorType {
case 0:
return 1, true // grayscale
case 2:
return 3, true // RGB
case 3:
return 1, true // palette
case 4:
return 2, true // gray + alpha
case 6:
return 4, true // RGBA
}
return 0, false
}
func validBitDepth(colorType, depth byte) bool {
switch colorType {
case 0:
return depth == 1 || depth == 2 || depth == 4 || depth == 8 || depth == 16
case 3:
return depth == 1 || depth == 2 || depth == 4 || depth == 8
case 2, 4, 6:
return depth == 8 || depth == 16
}
return false
}
// pngRowLen — длина одной отсканированной строки прохода: 1 байт фильтра +
// данные пикселей.
func pngRowLen(pw, bitsPerPixel int64) int64 {
return 1 + (pw*bitsPerPixel+7)/8
}
// expectedRaw — длина распакованного потока IDAT: строки с байтом фильтра.
func expectedRaw(w, h int64, bitsPerPixel int64, interlaced bool) int64 {
if !interlaced {
return h * pngRowLen(w, bitsPerPixel)
}
passes := [7][4]int64{{0, 0, 8, 8}, {4, 0, 8, 8}, {0, 4, 4, 8}, {2, 0, 4, 4}, {0, 2, 2, 4}, {1, 0, 2, 2}, {0, 1, 1, 2}}
var total int64
for _, p := range passes {
if w <= p[0] || h <= p[1] {
continue
}
pw := (w - p[0] + p[2] - 1) / p[2]
ph := (h - p[1] + p[3] - 1) / p[3]
total += ph * pngRowLen(pw, bitsPerPixel)
}
return total
}
// pngRows — итератор по (pw, ph) проходов Adam7 или единственного прохода.
// Используется, чтобы валидировать байт фильтра каждой строки, не зная
// заранее, как разбивается распакованный поток на проходы.
type pngPass struct {
pw, ph int64
}
func pngPasses(w, h int64, interlaced bool) []pngPass {
if !interlaced {
return []pngPass{{w, h}}
}
coords := [7][4]int64{{0, 0, 8, 8}, {4, 0, 8, 8}, {0, 4, 4, 8}, {2, 0, 4, 4}, {0, 2, 2, 4}, {1, 0, 2, 2}, {0, 1, 1, 2}}
out := make([]pngPass, 0, len(coords))
for _, p := range coords {
if w <= p[0] || h <= p[1] {
continue
}
pw := (w - p[0] + p[2] - 1) / p[2]
ph := (h - p[1] + p[3] - 1) / p[3]
out = append(out, pngPass{pw, ph})
}
return out
}
type pngChunk struct {
length uint32
typ [4]byte
}
func readChunkHeader(br *bufio.Reader) (pngChunk, error) {
var hdr [8]byte
if _, err := io.ReadFull(br, hdr[:]); err != nil {
return pngChunk{}, invalid("truncated chunk header")
}
c := pngChunk{length: binary.BigEndian.Uint32(hdr[:4])}
copy(c.typ[:], hdr[4:])
if c.length > 1<<31-1 {
return c, invalid("chunk too long")
}
for _, b := range c.typ {
if !((b >= 'A' && b <= 'Z') || (b >= 'a' && b <= 'z')) {
return c, invalid("bad chunk type")
}
}
return c, nil
}
// readChunkData читает тело chunk в dst (если не nil) и проверяет CRC.
func readChunkData(br *bufio.Reader, c pngChunk, dst io.Writer) error {
h := crc32.NewIEEE()
h.Write(c.typ[:])
w := io.Writer(h)
if dst != nil {
w = io.MultiWriter(h, dst)
}
if _, err := io.CopyN(w, br, int64(c.length)); err != nil {
return invalid("truncated %s chunk", c.typ[:])
}
var crc [4]byte
if _, err := io.ReadFull(br, crc[:]); err != nil {
return invalid("truncated CRC")
}
if binary.BigEndian.Uint32(crc[:]) != h.Sum32() {
return invalid("CRC mismatch in %s", c.typ[:])
}
return nil
}
// idatStream отдаёт данные подряд идущих IDAT-chunk как один поток.
type idatStream struct {
br *bufio.Reader
remaining uint32
crc uint32
next *pngChunk // первый chunk после последнего IDAT
err error
}
func (s *idatStream) Read(p []byte) (int, error) {
for s.remaining == 0 {
if s.err != nil || s.next != nil {
if s.err != nil {
return 0, s.err
}
return 0, io.EOF
}
if err := s.finishChunk(); err != nil {
s.err = err
return 0, err
}
c, err := readChunkHeader(s.br)
if err != nil {
s.err = err
return 0, err
}
if string(c.typ[:]) != "IDAT" {
s.next = &c
return 0, io.EOF
}
s.startChunk(c)
}
if uint32(len(p)) > s.remaining {
p = p[:s.remaining]
}
n, err := s.br.Read(p)
s.crc = crc32.Update(s.crc, crc32.IEEETable, p[:n])
s.remaining -= uint32(n)
if err != nil && err != io.EOF {
s.err = err
return n, err
}
if n == 0 && err == io.EOF {
s.err = invalid("truncated IDAT")
return 0, s.err
}
return n, nil
}
func (s *idatStream) startChunk(c pngChunk) {
s.remaining = c.length
s.crc = crc32.Update(0, crc32.IEEETable, c.typ[:])
}
func (s *idatStream) finishChunk() error {
var crc [4]byte
if _, err := io.ReadFull(s.br, crc[:]); err != nil {
return invalid("truncated CRC")
}
if binary.BigEndian.Uint32(crc[:]) != s.crc {
return invalid("CRC mismatch in IDAT")
}
return nil
}
// validatePNGStream проверяет распакованный поток: длину, кратность строкам
// и байты фильтра (0..4) в начале каждой строки каждого прохода.
func validatePNGStream(zr io.Reader, passes []pngPass, bitsPerPixel, want int64) error {
total := int64(0)
buf := make([]byte, 32*1024)
for _, pass := range passes {
rowLen := pngRowLen(pass.pw, bitsPerPixel)
for y := int64(0); y < pass.ph; y++ {
// читаем ровно одну строку, но чанками, чтобы не аллоцировать
// rowLen (может быть большой для широких изображений)
left := rowLen
first := true
for left > 0 {
chunk := int64(len(buf))
if left < chunk {
chunk = left
}
n, err := io.ReadFull(zr, buf[:chunk])
if err != nil {
if errors.Is(err, io.ErrUnexpectedEOF) || errors.Is(err, io.EOF) {
return invalid("truncated IDAT (got %d of %d)", total, want)
}
return invalid("corrupt image data")
}
if first {
if buf[0] > 4 {
return invalid("bad row filter %d", buf[0])
}
first = false
}
total += int64(n)
left -= int64(n)
}
}
}
// Проверяем, что распакованный поток ровно want байт (ни больше, ни меньше).
var extra [1]byte
n, err := zr.Read(extra[:])
if n != 0 {
return invalid("image data longer than expected")
}
if err != nil && !errors.Is(err, io.EOF) {
return invalid("corrupt image data")
}
if total != want {
return invalid("image data length %d, want %d", total, want)
}
return nil
}
func validatePNG(br *bufio.Reader, maxPixels int64) (Result, error) {
res := Result{Format: PNG}
sig := make([]byte, 8)
if _, err := io.ReadFull(br, sig); err != nil || !bytes.Equal(sig, pngSignature) {
return res, invalid("not a PNG")
}
c, err := readChunkHeader(br)
if err != nil {
return res, err
}
if string(c.typ[:]) != "IHDR" || c.length != 13 {
return res, invalid("IHDR must be first")
}
var ihdr bytes.Buffer
if err := readChunkData(br, c, &ihdr); err != nil {
return res, err
}
b := ihdr.Bytes()
w := int64(binary.BigEndian.Uint32(b[0:4]))
h := int64(binary.BigEndian.Uint32(b[4:8]))
depth, colorType, compression, filter, interlace := b[8], b[9], b[10], b[11], b[12]
res.Width, res.Height = int(w), int(h)
if w < 1 || h < 1 || w > 1<<31-1 || h > 1<<31-1 {
return res, invalid("bad dimensions")
}
// Лимит пикселей — до чтения и распаковки данных изображения.
if w*h > maxPixels {
return res, ErrTooLarge
}
ch, ok := channels(colorType)
if !ok || !validBitDepth(colorType, depth) || compression != 0 || filter != 0 || interlace > 1 {
return res, invalid("unsupported IHDR")
}
bpp := int64(ch) * int64(depth)
want := expectedRaw(w, h, bpp, interlace == 1)
passes := pngPasses(w, h, interlace == 1)
sawIDAT := false
for {
c, err := readChunkHeader(br)
if err != nil {
return res, err
}
switch string(c.typ[:]) {
case "IDAT":
if sawIDAT {
return res, invalid("non-consecutive IDAT")
}
sawIDAT = true
s := &idatStream{br: br}
s.startChunk(c)
zr, err := zlib.NewReader(s)
if err != nil {
return res, invalid("bad zlib header")
}
// Распаковка и проверка фильтров строк — без хранения пикселей.
if err := validatePNGStream(zr, passes, bpp, want); err != nil {
// Закрываем zlib, чтобы дочитать хвост CRC в idatStream, но
// игнорируем ошибку закрытия: она не важна для результата.
_ = zr.Close()
return res, err
}
if err := zr.Close(); err != nil && !errors.Is(err, io.EOF) {
return res, invalid("bad zlib trailer")
}
// Остаток IDAT (например, пустые chunk) дочитываем с проверкой CRC.
if _, err := io.Copy(io.Discard, s); err != nil {
return res, err
}
if s.next == nil {
return res, invalid("missing IEND")
}
c = *s.next
if string(c.typ[:]) == "IEND" {
if err := readChunkData(br, c, nil); err != nil {
return res, err
}
return res, nil
}
if err := readChunkData(br, c, nil); err != nil {
return res, err
}
case "IEND":
if !sawIDAT {
return res, invalid("no image data")
}
if err := readChunkData(br, c, nil); err != nil {
return res, err
}
return res, nil
case "IHDR":
return res, invalid("duplicate IHDR")
default:
if err := readChunkData(br, c, nil); err != nil {
return res, err
}
}
}
}
// --- JPEG ---
func isSOF(m byte) bool {
switch m {
case 0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF:
return true
}
return false
}
// readMarker читает 0xFF (с заполнителями) и код маркера.
func readMarker(br *bufio.Reader) (byte, error) {
b, err := br.ReadByte()
if err != nil {
return 0, invalid("truncated JPEG")
}
if b != 0xFF {
return 0, invalid("expected JPEG marker")
}
for b == 0xFF {
if b, err = br.ReadByte(); err != nil {
return 0, invalid("truncated JPEG")
}
}
return b, nil
}
func segmentLength(br *bufio.Reader) (int, error) {
var l [2]byte
if _, err := io.ReadFull(br, l[:]); err != nil {
return 0, invalid("truncated JPEG segment")
}
n := int(binary.BigEndian.Uint16(l[:]))
if n < 2 {
return 0, invalid("bad JPEG segment length")
}
return n - 2, nil
}
// skipEntropy пропускает сжатые данные скана и возвращает следующий маркер.
func skipEntropy(br *bufio.Reader) (byte, error) {
for {
b, err := br.ReadByte()
if err != nil {
return 0, invalid("truncated JPEG scan")
}
if b != 0xFF {
continue
}
for b == 0xFF {
if b, err = br.ReadByte(); err != nil {
return 0, invalid("truncated JPEG scan")
}
}
if b == 0x00 || (b >= 0xD0 && b <= 0xD7) {
continue // байт-заполнитель или RSTn внутри скана
}
return b, nil
}
}
// readSOF читает сегмент SOF и проверяет его структуру (ITU T.81, B.2.2):
// P(1) Y(2) X(2) Nf(1), затем Nf компонент по 3 байта. n — длина сегмента
// без двух байт поля длины. Возвращает (width, height).
func readSOF(br *bufio.Reader, n int) (int64, int64, error) {
if n < 6 {
return 0, 0, invalid("short SOF")
}
hdr := make([]byte, 6)
if _, err := io.ReadFull(br, hdr); err != nil {
return 0, 0, invalid("truncated SOF")
}
// hdr[0] — точность выборки (precision), не число компонент.
h := int64(binary.BigEndian.Uint16(hdr[1:3]))
w := int64(binary.BigEndian.Uint16(hdr[3:5]))
nf := int(hdr[5])
if nf == 0 {
return 0, 0, invalid("SOF without components")
}
if n != 6+3*nf {
return 0, 0, invalid("SOF length %d, want %d", n, 6+3*nf)
}
if _, err := br.Discard(3 * nf); err != nil {
return 0, 0, invalid("truncated SOF")
}
return w, h, nil
}
func validateJPEG(br *bufio.Reader, maxPixels int64) (Result, error) {
res := Result{Format: JPEG}
var soi [2]byte
if _, err := io.ReadFull(br, soi[:]); err != nil || soi != [2]byte{0xFF, 0xD8} {
return res, invalid("not a JPEG")
}
sawSOF, sawSOS := false, false
marker, err := readMarker(br)
if err != nil {
return res, err
}
for {
switch {
case marker == 0xD9: // EOI
if !sawSOF || !sawSOS {
return res, invalid("JPEG without frame or scan")
}
return res, nil
case marker == 0xD8:
return res, invalid("unexpected SOI")
case marker == 0x01 || (marker >= 0xD0 && marker <= 0xD7):
// маркеры без длины
case isSOF(marker):
n, err := segmentLength(br)
if err != nil {
return res, err
}
if sawSOF {
// читаем сегмент, но так и так вернём ошибку
_, _, _ = readSOF(br, n)
return res, invalid("multiple frames")
}
w, h, err := readSOF(br, n)
if err != nil {
return res, err
}
res.Width, res.Height = int(w), int(h)
if w < 1 || h < 1 {
return res, invalid("bad JPEG dimensions")
}
if w*h > maxPixels {
return res, ErrTooLarge
}
sawSOF = true
case marker == 0xDA: // SOS
if !sawSOF {
return res, invalid("scan before frame")
}
n, err := segmentLength(br)
if err != nil {
return res, err
}
// SOS: Ns + Ss + Se + Ah/Al + 2*Ns = 1 + 3 + 2*Ns = 4 + 2*Ns
if n < 4 {
return res, invalid("short SOS")
}
nsBuf := make([]byte, 1)
if _, err := io.ReadFull(br, nsBuf); err != nil {
return res, invalid("truncated SOS")
}
ns := int(nsBuf[0])
if ns < 1 {
return res, invalid("SOS without components")
}
if n != 4+2*ns {
return res, invalid("SOS length %d, want %d", n, 4+2*ns)
}
if _, err := br.Discard(n - 1); err != nil {
return res, invalid("truncated SOS")
}
sawSOS = true
if marker, err = skipEntropy(br); err != nil {
return res, err
}
continue
default:
n, err := segmentLength(br)
if err != nil {
return res, err
}
if _, err := br.Discard(n); err != nil {
return res, invalid("truncated JPEG segment")
}
}
if marker, err = readMarker(br); err != nil {
return res, err
}
}
}