и исправление imagecheck.go
This commit is contained in:
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user