593 lines
17 KiB
Go
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
|
|
}
|
|
}
|
|
}
|