forked from mtusi2026/mtusi2026lab6
140 lines
4.0 KiB
Go
140 lines
4.0 KiB
Go
package imagecheck
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/binary"
|
|
"errors"
|
|
"hash/crc32"
|
|
"image"
|
|
"image/color"
|
|
"image/jpeg"
|
|
"image/png"
|
|
"testing"
|
|
|
|
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
|
|
)
|
|
|
|
func sampleImage(w, h int) image.Image {
|
|
img := image.NewRGBA(image.Rect(0, 0, w, h))
|
|
for y := range h {
|
|
for x := range w {
|
|
img.Set(x, y, color.RGBA{uint8(x), uint8(y), 80, 255})
|
|
}
|
|
}
|
|
return img
|
|
}
|
|
|
|
func encodePNG(t *testing.T, w, h int) []byte {
|
|
t.Helper()
|
|
var b bytes.Buffer
|
|
if err := png.Encode(&b, sampleImage(w, h)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return b.Bytes()
|
|
}
|
|
|
|
func encodeJPEG(t *testing.T, w, h int) []byte {
|
|
t.Helper()
|
|
var b bytes.Buffer
|
|
if err := jpeg.Encode(&b, sampleImage(w, h), nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return b.Bytes()
|
|
}
|
|
|
|
// pngHeaderOnly — сигнатура и IHDR с заданными размерами, без пикселей: так выглядит «бомба».
|
|
func pngHeaderOnly(w, h uint32) []byte {
|
|
var ihdr bytes.Buffer
|
|
ihdr.WriteString("IHDR")
|
|
binary.Write(&ihdr, binary.BigEndian, w)
|
|
binary.Write(&ihdr, binary.BigEndian, h)
|
|
ihdr.Write([]byte{8, 6, 0, 0, 0})
|
|
var out bytes.Buffer
|
|
out.Write(pngMagic)
|
|
binary.Write(&out, binary.BigEndian, uint32(13))
|
|
out.Write(ihdr.Bytes())
|
|
binary.Write(&out, binary.BigEndian, crc32.ChecksumIEEE(ihdr.Bytes()))
|
|
return out.Bytes()
|
|
}
|
|
|
|
// check — обе стадии проверки в том порядке, в каком их вызывает сервис.
|
|
func check(ctx context.Context, c *Checker, data []byte) (string, error) {
|
|
r := bytes.NewReader(data)
|
|
contentType, err := c.Inspect(r)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if err := c.Decode(ctx, r); err != nil {
|
|
return "", err
|
|
}
|
|
return contentType, nil
|
|
}
|
|
|
|
func TestCheck(t *testing.T) {
|
|
validPNG := encodePNG(t, 20, 10)
|
|
validJPEG := encodeJPEG(t, 20, 10)
|
|
flipped := bytes.Clone(validPNG)
|
|
flipped[len(flipped)/2] ^= 0xff
|
|
|
|
cases := []struct {
|
|
name string
|
|
data []byte
|
|
want string
|
|
wantErr error
|
|
}{
|
|
{"png", validPNG, domain.ContentTypePNG, nil},
|
|
{"jpeg", validJPEG, domain.ContentTypeJPEG, nil},
|
|
{"empty", nil, "", ErrUnsupported},
|
|
{"text", []byte("<script>alert(1)</script>"), "", ErrUnsupported},
|
|
{"gif", []byte("GIF89a\x01\x00\x01\x00\x00\x00\x00;"), "", ErrUnsupported},
|
|
{"png magic only", pngMagic, "", ErrUnsupported},
|
|
{"jpeg magic only", jpegMagic, "", ErrUnsupported},
|
|
{"png truncated", validPNG[:len(validPNG)/2], "", ErrUnsupported},
|
|
{"jpeg truncated", validJPEG[:len(validJPEG)/2], "", ErrUnsupported},
|
|
{"png byte flipped", flipped, "", ErrUnsupported},
|
|
{"png header without pixels", pngHeaderOnly(20, 10), "", ErrUnsupported},
|
|
{"png pixel bomb", pngHeaderOnly(100000, 100000), "", ErrTooManyPixels},
|
|
}
|
|
c := New(1000)
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
got, err := check(context.Background(), c, tc.data)
|
|
if !errors.Is(err, tc.wantErr) {
|
|
t.Fatalf("err = %v, want %v", err, tc.wantErr)
|
|
}
|
|
if got != tc.want {
|
|
t.Errorf("type = %q, want %q", got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheck_PixelLimitIsInclusive(t *testing.T) {
|
|
c := New(200)
|
|
if _, err := check(context.Background(), c, encodePNG(t, 20, 10)); err != nil {
|
|
t.Errorf("exactly at limit: %v", err)
|
|
}
|
|
if _, err := check(context.Background(), c, encodePNG(t, 21, 10)); !errors.Is(err, ErrTooManyPixels) {
|
|
t.Errorf("over limit: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCheck_CancelledWhileWaitingForDecodeSlot(t *testing.T) {
|
|
c := New(1000)
|
|
c.decoding <- struct{}{}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
if _, err := check(ctx, c, encodePNG(t, 2, 2)); !errors.Is(err, context.Canceled) {
|
|
t.Errorf("err = %v, want context.Canceled", err)
|
|
}
|
|
}
|
|
|
|
func TestInspect_DoesNotNeedDecodeSlot(t *testing.T) {
|
|
c := New(1000)
|
|
c.decoding <- struct{}{} // декодер занят, но отказ по заголовку не должен его ждать
|
|
if _, err := c.Inspect(bytes.NewReader(pngHeaderOnly(100000, 100000))); !errors.Is(err, ErrTooManyPixels) {
|
|
t.Errorf("err = %v, want ErrTooManyPixels", err)
|
|
}
|
|
}
|