mirror of
https://github.com/warmbly/warmbly.git
synced 2026-11-17 16:19:13 +00:00
121 lines
4.0 KiB
Go
121 lines
4.0 KiB
Go
// Proposed test. Target: internal/api/handler/public_object_headers_test.go
|
|
package handler
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"image"
|
|
"image/png"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"net/textproto"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
|
|
"github.com/warmbly/warmbly/internal/infrastructure/storage"
|
|
)
|
|
|
|
func tinyPNG(t *testing.T) []byte {
|
|
t.Helper()
|
|
var buf bytes.Buffer
|
|
if err := png.Encode(&buf, image.NewRGBA(image.Rect(0, 0, 2, 2))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return buf.Bytes()
|
|
}
|
|
|
|
// A raster public key renders inline; any other key is a nosniff, sandboxed octet-stream download.
|
|
func TestServePublicObjectSetsProtectiveHeaders(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
store, err := storage.NewFilesystem(t.TempDir(), "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctx := context.Background()
|
|
if err := store.Put(ctx, "avatars/u1/a.png", bytes.NewReader(tinyPNG(t)), "image/png"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := store.Put(ctx, "avatars/u1/a.html", strings.NewReader("<script>alert(1)</script>"), "text/html"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
h := &Handler{Storage: store}
|
|
r := gin.New()
|
|
r.GET("/public/*key", h.ServePublicObject)
|
|
for _, tc := range []struct {
|
|
key, ctype, disposition string
|
|
}{
|
|
{"avatars/u1/a.png", "image/png", "inline"},
|
|
{"avatars/u1/a.html", "application/octet-stream", "attachment"},
|
|
} {
|
|
t.Run(tc.key, func(t *testing.T) {
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/public/"+tc.key, nil))
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("status = %d", w.Code)
|
|
}
|
|
if got := w.Header().Get("Content-Type"); got != tc.ctype {
|
|
t.Fatalf("Content-Type = %q, want %q", got, tc.ctype)
|
|
}
|
|
if got := w.Header().Get("Content-Disposition"); got != tc.disposition {
|
|
t.Fatalf("Content-Disposition = %q, want %q", got, tc.disposition)
|
|
}
|
|
if got := w.Header().Get("X-Content-Type-Options"); got != "nosniff" {
|
|
t.Fatalf("X-Content-Type-Options = %q", got)
|
|
}
|
|
if csp := w.Header().Get("Content-Security-Policy"); !strings.Contains(csp, "sandbox") || !strings.Contains(csp, "default-src 'none'") {
|
|
t.Fatalf("Content-Security-Policy = %q", csp)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// The declared type and filename take no part: content that is not a decodable PNG or JPEG is refused.
|
|
func TestReadImageUploadJudgesTheBytes(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
upload := func(name, declared string, body []byte) (string, string, bool) {
|
|
var buf bytes.Buffer
|
|
mw := multipart.NewWriter(&buf)
|
|
hdr := textproto.MIMEHeader{}
|
|
hdr.Set("Content-Disposition", `form-data; name="file"; filename="`+name+`"`)
|
|
hdr.Set("Content-Type", declared)
|
|
part, err := mw.CreatePart(hdr)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, _ = part.Write(body)
|
|
_ = mw.Close()
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/upload", &buf)
|
|
c.Request.Header.Set("Content-Type", mw.FormDataContentType())
|
|
_, mime, ext, e := readImageUpload(c, avatarLimits)
|
|
return mime, ext, e == nil
|
|
}
|
|
good := tinyPNG(t)
|
|
for name, tc := range map[string]struct {
|
|
file, declared string
|
|
body []byte
|
|
}{
|
|
"html named png": {"a.png", "image/png", []byte("<html><script>alert(1)</script></html>")},
|
|
"svg declared png": {"a.png", "image/png", []byte(`<svg xmlns="http://www.w3.org/2000/svg" onload="alert(1)"/>`)},
|
|
"fake webp with html": {"a.webp", "image/webp", append([]byte("RIFF\x24\x00\x00\x00WEBPVP8 "), []byte("<script>alert(1)</script>")...)},
|
|
"truncated png": {"a.png", "image/png", good[:12]},
|
|
"png bytes, webp name": {"a.webp", "image/webp", append(append([]byte{}, good[:12]...), []byte("<script>")...)},
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
if _, _, ok := upload(tc.file, tc.declared, tc.body); ok {
|
|
t.Fatal("disguised content was accepted")
|
|
}
|
|
})
|
|
}
|
|
t.Run("real png declared as html", func(t *testing.T) {
|
|
mime, ext, ok := upload("a.html", "text/html", good)
|
|
if !ok || mime != "image/png" || ext != ".png" {
|
|
t.Fatalf("got %q %q %v, want image/png .png accepted", mime, ext, ok)
|
|
}
|
|
})
|
|
}
|