From df5de9941d7a37b5290db145e29242aa0ac5c8b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D0=BD=D0=B4=D1=80=D0=B5=D0=B9=20=D0=92=D0=B5=D0=B9?= =?UTF-8?q?=D0=BD=D0=BC=D0=B0=D0=B9=D0=B5=D1=80?= <64+weinmaierandrew@noreply.gitea.privcloud.tech> Date: Sat, 7 Nov 2026 00:50:57 +0300 Subject: [PATCH] =?UTF-8?q?=D0=B8=20=D0=B8=D1=81=D0=BF=D1=80=D0=B0=D0=B2?= =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D0=B8=D0=B5=20imagecheck.go?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/imagecheck/imagecheck.go | 177 ++++++++++++++++++++++++------ 1 file changed, 146 insertions(+), 31 deletions(-) diff --git a/internal/imagecheck/imagecheck.go b/internal/imagecheck/imagecheck.go index ffb90f4e..2c27f235 100644 --- a/internal/imagecheck/imagecheck.go +++ b/internal/imagecheck/imagecheck.go @@ -2,10 +2,11 @@ // // Проверка идёт по мере чтения (используется параллельно с PUT в S3), память // O(1) от размера изображения: размеры берутся из заголовка (IHDR/SOF) и -// сравниваются с лимитом до чтения тела; PNG — CRC каждого chunk и длина -// распакованного IDAT-потока (zlib → io.Discard), JPEG — структура сегментов -// и маркер EOI. «Заведомо повреждённые» файлы (обрыв, битый CRC, мусор вместо -// данных, чужой формат) дают ErrInvalid, слишком большие по пикселям — ErrTooLarge. +// сравниваются с лимитом до чтения тела; PNG — CRC каждого chunk, длина +// распакованного IDAT-потока (zlib → io.Discard) и байт фильтра каждой строки, +// JPEG — структура сегментов и маркер EOI. «Заведомо повреждённые» файлы +// (обрыв, битый CRC, мусор вместо данных, чужой формат) дают ErrInvalid, +// слишком большие по пикселям — ErrTooLarge. package imagecheck import ( @@ -105,11 +106,16 @@ func validBitDepth(colorType, depth byte) bool { 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 { - row := func(pw int64) int64 { return 1 + (pw*bitsPerPixel+7)/8 } if !interlaced { - return h * row(w) + 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 @@ -119,11 +125,35 @@ func expectedRaw(w, h int64, bitsPerPixel int64, interlaced bool) int64 { } pw := (w - p[0] + p[2] - 1) / p[2] ph := (h - p[1] + p[3] - 1) / p[3] - total += ph * row(pw) + 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 @@ -233,6 +263,56 @@ func (s *idatStream) finishChunk() error { 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) @@ -266,7 +346,9 @@ func validatePNG(br *bufio.Reader, maxPixels int64) (Result, error) { if !ok || !validBitDepth(colorType, depth) || compression != 0 || filter != 0 || interlace > 1 { return res, invalid("unsupported IHDR") } - want := expectedRaw(w, h, int64(ch)*int64(depth), interlace == 1) + bpp := int64(ch) * int64(depth) + want := expectedRaw(w, h, bpp, interlace == 1) + passes := pngPasses(w, h, interlace == 1) sawIDAT := false for { @@ -286,16 +368,15 @@ func validatePNG(br *bufio.Reader, maxPixels int64) (Result, error) { if err != nil { return res, invalid("bad zlib header") } - // Распаковка в никуда: проверяем длину без хранения пикселей. - n, err := io.Copy(io.Discard, io.LimitReader(zr, want+1)) - if err != nil { - if errors.Is(err, ErrInvalid) { - return res, err - } - return res, invalid("corrupt image data") + // Распаковка и проверка фильтров строк — без хранения пикселей. + if err := validatePNGStream(zr, passes, bpp, want); err != nil { + // Закрываем zlib, чтобы дочитать хвост CRC в idatStream, но + // игнорируем ошибку закрытия: она не важна для результата. + _ = zr.Close() + return res, err } - if n != want { - return res, invalid("image data length %d, want %d", n, want) + 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 { @@ -393,6 +474,31 @@ func skipEntropy(br *bufio.Reader) (byte, error) { } } +// readSOF читает сегмент SOF и проверяет его структуру: Nf компонент и ровно +// 3 байта на компоненту. Возвращает (width, height, ok). +func readSOF(br *bufio.Reader, n int) (int64, int64, error) { + if n < 6 { + return 0, 0, invalid("short SOF") + } + hdr := make([]byte, 5) + if _, err := io.ReadFull(br, hdr); err != nil { + return 0, 0, invalid("truncated SOF") + } + nf := int(hdr[0]) + h := int64(binary.BigEndian.Uint16(hdr[1:3])) + w := int64(binary.BigEndian.Uint16(hdr[3:5])) + if nf == 0 { + return 0, 0, invalid("SOF without components") + } + if n != 5+3*nf { + return 0, 0, invalid("SOF length %d, want %d", n, 5+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 @@ -420,15 +526,15 @@ func validateJPEG(br *bufio.Reader, maxPixels int64) (Result, error) { if err != nil { return res, err } - if n < 6 { - return res, invalid("short SOF") + if sawSOF { + // читаем сегмент, но так и так вернём ошибку + _, _, _ = readSOF(br, n) + return res, invalid("multiple frames") } - hdr := make([]byte, 5) - if _, err := io.ReadFull(br, hdr); err != nil { - return res, invalid("truncated SOF") + w, h, err := readSOF(br, n) + if err != nil { + return res, err } - h := int64(binary.BigEndian.Uint16(hdr[1:3])) - w := int64(binary.BigEndian.Uint16(hdr[3:5])) res.Width, res.Height = int(w), int(h) if w < 1 || h < 1 { return res, invalid("bad JPEG dimensions") @@ -436,13 +542,7 @@ func validateJPEG(br *bufio.Reader, maxPixels int64) (Result, error) { if w*h > maxPixels { return res, ErrTooLarge } - if sawSOF { - return res, invalid("multiple frames") - } sawSOF = true - if _, err := br.Discard(n - 5); err != nil { - return res, invalid("truncated SOF") - } case marker == 0xDA: // SOS if !sawSOF { return res, invalid("scan before frame") @@ -451,7 +551,22 @@ func validateJPEG(br *bufio.Reader, maxPixels int64) (Result, error) { if err != nil { return res, err } - if _, err := br.Discard(n); err != nil { + // 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