增加复制粘贴交互
This commit is contained in:
andy committed
1 parent
4195525dc7
commit
deb9cc5bcf
14 files changed
+1144
-31
No files matched your search
@@ -0,0 +1,225 @@
|
||||
package assets
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"image"
|
||||
_ "image/gif"
|
||||
_ "image/jpeg"
|
||||
_ "image/png"
|
||||
"io"
|
||||
"net/url"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrImportImageURL = errors.New("invalid image URL")
|
||||
ErrImportImageUnavailable = errors.New("image URL is unavailable")
|
||||
ErrImportImageUnsupported = errors.New("unsupported image format")
|
||||
)
|
||||
|
||||
const (
|
||||
maxImportImageURLBytes = 8192
|
||||
maxImportImageBytes = 20 << 20
|
||||
maxImportImagePixels = 25_000_000
|
||||
)
|
||||
|
||||
// ImportImage fetches an untrusted image into the configured blob store using
|
||||
// the same write ordering and catalog compensation as a regular upload.
|
||||
func (s *Service) ImportImage(ctx context.Context, scope Scope, rawURL string) (Asset, error) {
|
||||
if err := validScope(scope); err != nil {
|
||||
return Asset{}, err
|
||||
}
|
||||
if scope.kind != platformScope {
|
||||
return Asset{}, ErrImportImageURL
|
||||
}
|
||||
if len(rawURL) == 0 || len(rawURL) > maxImportImageURLBytes || strings.TrimSpace(rawURL) != rawURL {
|
||||
return Asset{}, ErrImportImageURL
|
||||
}
|
||||
u, err := url.Parse(rawURL)
|
||||
if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" || u.User != nil {
|
||||
return Asset{}, ErrImportImageURL
|
||||
}
|
||||
if s.remote == nil {
|
||||
return Asset{}, ErrImportImageUnavailable
|
||||
}
|
||||
blob, err := s.remote.Fetch(ctx, rawURL)
|
||||
if err != nil {
|
||||
if errors.Is(err, ErrRemoteTooLarge) {
|
||||
return Asset{}, ErrRemoteTooLarge
|
||||
}
|
||||
return Asset{}, ErrImportImageUnavailable
|
||||
}
|
||||
if blob.Body == nil {
|
||||
return Asset{}, ErrImportImageUnavailable
|
||||
}
|
||||
defer blob.Body.Close()
|
||||
if blob.Size > maxImportImageBytes {
|
||||
return Asset{}, ErrRemoteTooLarge
|
||||
}
|
||||
content, err := io.ReadAll(io.LimitReader(blob.Body, maxImportImageBytes+1))
|
||||
if err != nil {
|
||||
return Asset{}, ErrImportImageUnavailable
|
||||
}
|
||||
if len(content) > maxImportImageBytes {
|
||||
return Asset{}, ErrRemoteTooLarge
|
||||
}
|
||||
extension, mime, ok := inspectImportedImage(content)
|
||||
if !ok {
|
||||
return Asset{}, ErrImportImageUnsupported
|
||||
}
|
||||
return s.Upload(ctx, scope, UploadCommand{Bytes: content, FileName: "导入图片" + extension, ContentType: mime, Kind: KindImage})
|
||||
}
|
||||
|
||||
func inspectImportedImage(content []byte) (string, string, bool) {
|
||||
if len(content) < 12 {
|
||||
return "", "", false
|
||||
}
|
||||
if bytes.Equal(content[:4], []byte("RIFF")) && bytes.Equal(content[8:12], []byte("WEBP")) {
|
||||
if validWebP(content) {
|
||||
return ".webp", "image/webp", true
|
||||
}
|
||||
return "", "", false
|
||||
}
|
||||
if content[0] == 'B' && content[1] == 'M' {
|
||||
if validBMP(content) {
|
||||
return ".bmp", "image/bmp", true
|
||||
}
|
||||
return "", "", false
|
||||
}
|
||||
config, format, err := image.DecodeConfig(bytes.NewReader(content))
|
||||
if err != nil || !validImageDimensions(config.Width, config.Height) {
|
||||
return "", "", false
|
||||
}
|
||||
// Decode the first frame so that a forged or truncated header cannot be
|
||||
// stored as a supported image. DecodeConfig alone checks only the header.
|
||||
if _, _, err = image.Decode(bytes.NewReader(content)); err != nil {
|
||||
return "", "", false
|
||||
}
|
||||
switch format {
|
||||
case "png":
|
||||
return ".png", "image/png", true
|
||||
case "jpeg":
|
||||
return ".jpg", "image/jpeg", true
|
||||
case "gif":
|
||||
return ".gif", "image/gif", true
|
||||
default:
|
||||
return "", "", false
|
||||
}
|
||||
}
|
||||
|
||||
func validImageDimensions(width, height int) bool {
|
||||
return width > 0 && height > 0 && int64(width)*int64(height) <= maxImportImagePixels
|
||||
}
|
||||
|
||||
// The standard library does not decode WebP or BMP. Validate their containers,
|
||||
// image headers and dimensions before accepting the original raster bytes.
|
||||
func validWebP(b []byte) bool {
|
||||
if len(b) < 30 || uint64(binary.LittleEndian.Uint32(b[4:8]))+8 != uint64(len(b)) {
|
||||
return false
|
||||
}
|
||||
first, payload, next, ok := webPChunk(b, 12)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
if first == "VP8 " || first == "VP8L" {
|
||||
_, _, valid := webPImageDimensions(first, payload)
|
||||
return valid && next == len(b)
|
||||
}
|
||||
if first != "VP8X" || len(payload) != 10 || payload[0]&^byte(0x3e) != 0 || payload[1] != 0 || payload[2] != 0 || payload[3] != 0 {
|
||||
return false
|
||||
}
|
||||
// Animation requires ANIM/ANMF frame handling; reject it in this version.
|
||||
if payload[0]&0x02 != 0 {
|
||||
return false
|
||||
}
|
||||
canvasWidth := 1 + int(payload[4]) + (int(payload[5]) << 8) + (int(payload[6]) << 16)
|
||||
canvasHeight := 1 + int(payload[7]) + (int(payload[8]) << 8) + (int(payload[9]) << 16)
|
||||
if !validImageDimensions(canvasWidth, canvasHeight) {
|
||||
return false
|
||||
}
|
||||
images := 0
|
||||
for next < len(b) {
|
||||
chunk, data, after, ok := webPChunk(b, next)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
switch chunk {
|
||||
case "VP8 ", "VP8L":
|
||||
width, height, valid := webPImageDimensions(chunk, data)
|
||||
if !valid || width != canvasWidth || height != canvasHeight || images != 0 {
|
||||
return false
|
||||
}
|
||||
images++
|
||||
case "ALPH", "ICCP", "EXIF", "XMP ":
|
||||
if len(data) == 0 {
|
||||
return false
|
||||
}
|
||||
default:
|
||||
return false
|
||||
}
|
||||
next = after
|
||||
}
|
||||
return images == 1
|
||||
}
|
||||
|
||||
func webPChunk(b []byte, offset int) (string, []byte, int, bool) {
|
||||
if offset > len(b)-8 {
|
||||
return "", nil, 0, false
|
||||
}
|
||||
size := uint64(binary.LittleEndian.Uint32(b[offset+4 : offset+8]))
|
||||
end := uint64(offset) + 8 + size + (size & 1)
|
||||
if size == 0 || end > uint64(len(b)) {
|
||||
return "", nil, 0, false
|
||||
}
|
||||
return string(b[offset : offset+4]), b[offset+8 : offset+8+int(size)], int(end), true
|
||||
}
|
||||
|
||||
func webPImageDimensions(chunk string, payload []byte) (int, int, bool) {
|
||||
switch chunk {
|
||||
case "VP8 ":
|
||||
if len(payload) < 10 || payload[0]&1 != 0 || !bytes.Equal(payload[3:6], []byte{0x9d, 0x01, 0x2a}) {
|
||||
return 0, 0, false
|
||||
}
|
||||
partitionBytes := int(payload[0]) | int(payload[1])<<8 | int(payload[2])<<16
|
||||
if partitionBytes>>5 > len(payload)-10 {
|
||||
return 0, 0, false
|
||||
}
|
||||
width := int(binary.LittleEndian.Uint16(payload[6:8]) & 0x3fff)
|
||||
height := int(binary.LittleEndian.Uint16(payload[8:10]) & 0x3fff)
|
||||
return width, height, validImageDimensions(width, height)
|
||||
case "VP8L":
|
||||
if len(payload) <= 5 || payload[0] != 0x2f || payload[4]&0xe0 != 0 {
|
||||
return 0, 0, false
|
||||
}
|
||||
width := 1 + int(payload[1]) + (int(payload[2]&0x3f) << 8)
|
||||
height := 1 + int(payload[2]>>6) + (int(payload[3]) << 2) + (int(payload[4]&0x0f) << 10)
|
||||
return width, height, validImageDimensions(width, height)
|
||||
}
|
||||
return 0, 0, false
|
||||
}
|
||||
|
||||
func validBMP(b []byte) bool {
|
||||
if len(b) < 54 || int(binary.LittleEndian.Uint32(b[2:6])) != len(b) {
|
||||
return false
|
||||
}
|
||||
offset := int(binary.LittleEndian.Uint32(b[10:14]))
|
||||
header := binary.LittleEndian.Uint32(b[14:18])
|
||||
if header < 40 || int(header) > len(b)-14 || offset < 14+int(header) || offset >= len(b) {
|
||||
return false
|
||||
}
|
||||
width := int(int32(binary.LittleEndian.Uint32(b[18:22])))
|
||||
height := int(int32(binary.LittleEndian.Uint32(b[22:26])))
|
||||
if height < 0 {
|
||||
height = -height
|
||||
}
|
||||
depth := binary.LittleEndian.Uint16(b[28:30])
|
||||
compression := binary.LittleEndian.Uint32(b[30:34])
|
||||
if !validImageDimensions(width, height) || binary.LittleEndian.Uint16(b[26:28]) != 1 || compression != 0 || (depth != 24 && depth != 32) {
|
||||
return false
|
||||
}
|
||||
stride := (int64(width)*int64(depth) + 31) / 32 * 4
|
||||
return stride*int64(height) <= int64(len(b)-offset)
|
||||
}
|
||||
@@ -0,0 +1,261 @@
|
||||
package assets
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"image"
|
||||
"image/gif"
|
||||
"io"
|
||||
"net"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
type importFetcher func(context.Context, string) (Blob, error)
|
||||
|
||||
func (f importFetcher) Fetch(ctx context.Context, u string) (Blob, error) { return f(ctx, u) }
|
||||
|
||||
func TestImportImageStoresRecognizedBytesAsUpload(t *testing.T) {
|
||||
pngData, jpegData, webpData := imageFormatFixtures(t)
|
||||
var gifBuffer bytes.Buffer
|
||||
if err := gif.Encode(&gifBuffer, image.NewRGBA(image.Rect(0, 0, 2, 2)), nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, tc := range []struct {
|
||||
name, ext, mime string
|
||||
data []byte
|
||||
}{
|
||||
{"png", ".png", "image/png", pngData},
|
||||
{"jpeg", ".jpg", "image/jpeg", jpegData},
|
||||
{"webp", ".webp", "image/webp", webpData},
|
||||
{"gif", ".gif", "image/gif", gifBuffer.Bytes()},
|
||||
{"bmp", ".bmp", "image/bmp", importBMP()},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
cat, store := &memoryCatalog{}, &memoryBlobs{}
|
||||
svc := NewService(cat, store, importFetcher(func(context.Context, string) (Blob, error) {
|
||||
return Blob{Body: io.NopCloser(bytes.NewReader(tc.data)), ContentType: "text/html", Size: int64(len(tc.data))}, nil
|
||||
}), nil, func(prefix string) string { return prefix + "-1" })
|
||||
asset, err := svc.ImportImage(context.Background(), PlatformScope("owner-a"), "https://images.test/picture.svg?secret=signed")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if asset.OwnerID != "owner-a" || asset.Source != SourceUpload || asset.Kind != KindImage || asset.Name != "导入图片"+tc.ext || asset.Metadata["contentType"] != tc.mime || store.putContentType != tc.mime || !bytes.Equal(store.putBody, tc.data) || len(cat.assets) != 1 {
|
||||
t.Fatalf("asset=%#v store=%q", asset, store.putContentType)
|
||||
}
|
||||
if bytes.Contains([]byte(asset.URL), []byte("signed")) || asset.Metadata["importedFrom"] != nil {
|
||||
t.Fatalf("remote URL persisted: %#v", asset)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestImportImageRejectsInvalidInputWithoutCreatingRecord(t *testing.T) {
|
||||
pngData, _, _ := imageFormatFixtures(t)
|
||||
for _, tc := range []struct {
|
||||
name, url string
|
||||
data []byte
|
||||
want error
|
||||
}{
|
||||
{"svg", "https://images.test/a.svg", []byte(`<svg xmlns="http://www.w3.org/2000/svg"/>`), ErrImportImageUnsupported},
|
||||
{"html", "https://images.test/a.png", []byte("<html>login</html>"), ErrImportImageUnsupported},
|
||||
{"fake png", "https://images.test/a.png", []byte("not png"), ErrImportImageUnsupported},
|
||||
{"truncated png", "https://images.test/a.png", pngData[:32], ErrImportImageUnsupported},
|
||||
{"userinfo", "https://user:password@images.test/a.png", pngData, ErrImportImageURL},
|
||||
{"protocol", "file:///etc/passwd", pngData, ErrImportImageURL},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
cat, store := &memoryCatalog{}, &memoryBlobs{}
|
||||
svc := NewService(cat, store, importFetcher(func(context.Context, string) (Blob, error) {
|
||||
return Blob{Body: io.NopCloser(bytes.NewReader(tc.data)), Size: int64(len(tc.data))}, nil
|
||||
}), nil, nil)
|
||||
if _, err := svc.ImportImage(context.Background(), PlatformScope("owner"), tc.url); !errors.Is(err, tc.want) {
|
||||
t.Fatalf("err=%v want=%v", err, tc.want)
|
||||
}
|
||||
if len(cat.assets) != 0 || store.putKey != "" {
|
||||
t.Fatalf("persisted on rejection: %#v %q", cat.assets, store.putKey)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestImportImageBoundsAndCompensation(t *testing.T) {
|
||||
pngData, _, _ := imageFormatFixtures(t)
|
||||
cat, store := &memoryCatalog{createErr: errors.New("db down")}, &memoryBlobs{}
|
||||
svc := NewService(cat, store, importFetcher(func(context.Context, string) (Blob, error) {
|
||||
return Blob{Body: io.NopCloser(bytes.NewReader(pngData)), Size: int64(len(pngData))}, nil
|
||||
}), nil, nil)
|
||||
if _, err := svc.ImportImage(context.Background(), PlatformScope("owner"), "https://images.test/a.png"); !errors.Is(err, cat.createErr) || len(store.deleted) != 1 {
|
||||
t.Fatalf("err=%v deleted=%v", err, store.deleted)
|
||||
}
|
||||
cat2, store2 := &memoryCatalog{}, &memoryBlobs{}
|
||||
svc2 := NewService(cat2, store2, importFetcher(func(context.Context, string) (Blob, error) {
|
||||
return Blob{Body: io.NopCloser(bytes.NewReader(pngData)), Size: maxImportImageBytes + 1}, nil
|
||||
}), nil, nil)
|
||||
if _, err := svc2.ImportImage(context.Background(), PlatformScope("owner"), "https://images.test/a.png"); !errors.Is(err, ErrRemoteTooLarge) || len(cat2.assets) != 0 {
|
||||
t.Fatalf("err=%v records=%d", err, len(cat2.assets))
|
||||
}
|
||||
cat3, store3 := &memoryCatalog{}, &memoryBlobs{}
|
||||
svc3 := NewService(cat3, store3, importFetcher(func(context.Context, string) (Blob, error) {
|
||||
return Blob{Body: io.NopCloser(io.LimitReader(&repeatingReader{value: 'x'}, maxImportImageBytes+1)), Size: -1}, nil
|
||||
}), nil, nil)
|
||||
if _, err := svc3.ImportImage(context.Background(), PlatformScope("owner"), "https://images.test/a.png"); !errors.Is(err, ErrRemoteTooLarge) || len(cat3.assets) != 0 || store3.putKey != "" {
|
||||
t.Fatalf("unknown length error=%v records=%d key=%q", err, len(cat3.assets), store3.putKey)
|
||||
}
|
||||
cat4, store4 := &memoryCatalog{}, &failingImportBlobStore{memoryBlobs: &memoryBlobs{}}
|
||||
svc4 := NewService(cat4, store4, importFetcher(func(context.Context, string) (Blob, error) {
|
||||
return Blob{Body: io.NopCloser(bytes.NewReader(pngData)), Size: int64(len(pngData))}, nil
|
||||
}), nil, nil)
|
||||
if _, err := svc4.ImportImage(context.Background(), PlatformScope("owner"), "https://images.test/a.png"); !errors.Is(err, store4.failure) || len(cat4.assets) != 0 {
|
||||
t.Fatalf("put failure error=%v records=%d", err, len(cat4.assets))
|
||||
}
|
||||
}
|
||||
|
||||
type repeatingReader struct{ value byte }
|
||||
|
||||
func (r *repeatingReader) Read(p []byte) (int, error) {
|
||||
for i := range p {
|
||||
p[i] = r.value
|
||||
}
|
||||
return len(p), nil
|
||||
}
|
||||
|
||||
type failingImportBlobStore struct {
|
||||
*memoryBlobs
|
||||
failure error
|
||||
}
|
||||
|
||||
func (s *failingImportBlobStore) Put(context.Context, string, io.Reader, int64, string) (StoredObject, error) {
|
||||
if s.failure == nil {
|
||||
s.failure = errors.New("object store failed")
|
||||
}
|
||||
return StoredObject{}, s.failure
|
||||
}
|
||||
|
||||
func TestImportImageURLLengthAndSafeFetcherError(t *testing.T) {
|
||||
pngData, _, _ := imageFormatFixtures(t)
|
||||
remoteCalled := false
|
||||
remote := importFetcher(func(_ context.Context, _ string) (Blob, error) {
|
||||
remoteCalled = true
|
||||
return Blob{Body: io.NopCloser(bytes.NewReader(pngData)), Size: int64(len(pngData))}, nil
|
||||
})
|
||||
svc := NewService(&memoryCatalog{}, &memoryBlobs{}, remote, nil, nil)
|
||||
base := "https://images.test/a.png?signature="
|
||||
allowed := base + strings.Repeat("x", maxImportImageURLBytes-len(base))
|
||||
if _, err := svc.ImportImage(context.Background(), PlatformScope("owner"), allowed); err != nil || !remoteCalled {
|
||||
t.Fatalf("8192-byte URL err=%v called=%v", err, remoteCalled)
|
||||
}
|
||||
remoteCalled = false
|
||||
if _, err := svc.ImportImage(context.Background(), PlatformScope("owner"), allowed+"x"); !errors.Is(err, ErrImportImageURL) || remoteCalled {
|
||||
t.Fatalf("overlong URL err=%v called=%v", err, remoteCalled)
|
||||
}
|
||||
secret := "https://images.test/a.png?signature=secret-value"
|
||||
svc = NewService(&memoryCatalog{}, &memoryBlobs{}, importFetcher(func(context.Context, string) (Blob, error) { return Blob{}, errors.New("GET " + secret + ": timeout") }), nil, nil)
|
||||
if _, err := svc.ImportImage(context.Background(), PlatformScope("owner"), secret); !errors.Is(err, ErrImportImageUnavailable) || strings.Contains(err.Error(), "secret-value") {
|
||||
t.Fatalf("unsafe fetch error=%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestImportImageRejectsPrivateDestinationsAndPrivateRedirectWithProductionPolicy(t *testing.T) {
|
||||
privateDialer := &importRedirectDialer{}
|
||||
policy := NewPublicDestinationPolicy(nil, privateDialer)
|
||||
fetcher, err := NewPublicHTTPRemoteFetcher(time.Second, maxImportImageBytes, policy)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, target := range []string{"http://127.0.0.1/a.png", "http://169.254.169.254/latest/meta-data", "http://[::1]/a.png"} {
|
||||
cat := &memoryCatalog{}
|
||||
svc := NewService(cat, &memoryBlobs{}, fetcher, nil, nil)
|
||||
if _, err := svc.ImportImage(context.Background(), PlatformScope("owner"), target); !errors.Is(err, ErrImportImageUnavailable) || len(cat.assets) != 0 {
|
||||
t.Fatalf("private target %q err=%v assets=%d", target, err, len(cat.assets))
|
||||
}
|
||||
}
|
||||
if privateDialer.calls != 0 {
|
||||
t.Fatalf("private targets reached dialer %d times", privateDialer.calls)
|
||||
}
|
||||
dialer := &importRedirectDialer{}
|
||||
policy = NewPublicDestinationPolicy(nil, dialer)
|
||||
fetcher, err = NewPublicHTTPRemoteFetcher(time.Second, maxImportImageBytes, policy)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cat := &memoryCatalog{}
|
||||
svc := NewService(cat, &memoryBlobs{}, fetcher, nil, nil)
|
||||
if _, err := svc.ImportImage(context.Background(), PlatformScope("owner"), "http://8.8.8.8/a.png?signature=secret"); !errors.Is(err, ErrImportImageUnavailable) || len(cat.assets) != 0 || dialer.calls != 1 {
|
||||
t.Fatalf("private redirect err=%v assets=%d dial calls=%d", err, len(cat.assets), dialer.calls)
|
||||
}
|
||||
}
|
||||
|
||||
type importRedirectDialer struct{ calls int }
|
||||
|
||||
func (d *importRedirectDialer) DialContext(context.Context, string, string) (net.Conn, error) {
|
||||
d.calls++
|
||||
client, server := net.Pipe()
|
||||
go func() {
|
||||
_, _ = io.WriteString(server, "HTTP/1.1 302 Found\r\nLocation: http://169.254.169.254/private\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")
|
||||
_ = server.Close()
|
||||
}()
|
||||
return client, nil
|
||||
}
|
||||
|
||||
func TestImportImageRejectsFakeExtendedWebP(t *testing.T) {
|
||||
// Valid canvas metadata with an unrelated trailing chunk is not an image.
|
||||
webp := make([]byte, 12)
|
||||
copy(webp, "RIFF")
|
||||
copy(webp[8:], "WEBP")
|
||||
webp = appendWebPChunk(webp, "VP8X", []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0})
|
||||
webp = appendWebPChunk(webp, "EXIF", []byte("fake"))
|
||||
binary.LittleEndian.PutUint32(webp[4:8], uint32(len(webp)-8))
|
||||
if validWebP(webp) {
|
||||
t.Fatal("VP8X without image payload accepted")
|
||||
}
|
||||
webp = appendWebPChunk(webp, "ANMF", []byte("fake"))
|
||||
binary.LittleEndian.PutUint32(webp[4:8], uint32(len(webp)-8))
|
||||
if validWebP(webp) {
|
||||
t.Fatal("animation payload accepted")
|
||||
}
|
||||
_, _, simple := imageFormatFixtures(t)
|
||||
valid := make([]byte, 12)
|
||||
copy(valid, "RIFF")
|
||||
copy(valid[8:], "WEBP")
|
||||
valid = appendWebPChunk(valid, "VP8X", []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0})
|
||||
valid = append(valid, simple[12:]...)
|
||||
binary.LittleEndian.PutUint32(valid[4:8], uint32(len(valid)-8))
|
||||
if !validWebP(valid) {
|
||||
t.Fatal("valid extended still WebP was rejected")
|
||||
}
|
||||
}
|
||||
|
||||
func TestImportImagePixelLimit(t *testing.T) {
|
||||
if !validImageDimensions(5000, 5000) || validImageDimensions(5001, 5000) || validImageDimensions(0, 1) {
|
||||
t.Fatal("pixel limit does not enforce 25 million positive pixels")
|
||||
}
|
||||
}
|
||||
|
||||
func appendWebPChunk(b []byte, name string, data []byte) []byte {
|
||||
b = append(b, []byte(name)...)
|
||||
var size [4]byte
|
||||
binary.LittleEndian.PutUint32(size[:], uint32(len(data)))
|
||||
b = append(b, size[:]...)
|
||||
b = append(b, data...)
|
||||
if len(data)&1 != 0 {
|
||||
b = append(b, 0)
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func importBMP() []byte {
|
||||
b := make([]byte, 70)
|
||||
copy(b, "BM")
|
||||
binary.LittleEndian.PutUint32(b[2:6], uint32(len(b)))
|
||||
binary.LittleEndian.PutUint32(b[10:14], 54)
|
||||
binary.LittleEndian.PutUint32(b[14:18], 40)
|
||||
binary.LittleEndian.PutUint32(b[18:22], 2)
|
||||
binary.LittleEndian.PutUint32(b[22:26], 2)
|
||||
binary.LittleEndian.PutUint16(b[26:28], 1)
|
||||
binary.LittleEndian.PutUint16(b[28:30], 24)
|
||||
return b
|
||||
}
|
||||
Reference in new issue
Block a user