@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/net/http/sniff.go

@@ -4,13 +4,7 @@
 
 package http
 
-import (
-	"bytes"
-	"encoding/binary"
-)
-
-// The algorithm uses at most sniffLen bytes to make its decision.
-const sniffLen = 512
+import "net/http/internal"
 
 // DetectContentType implements the algorithm described
 // at https://mimesniff.spec.whatwg.org/ to determine the
@@ -19,286 +13,5 @@ const sniffLen = 512
 // a valid MIME type: if it cannot determine a more specific one, it
 // returns "application/octet-stream".
 func DetectContentType(data []byte) string {
-	if len(data) > sniffLen {
-		data = data[:sniffLen]
-	}
-
-	// Index of the first non-whitespace byte in data.
-	firstNonWS := 0
-	for ; firstNonWS < len(data) && isWS(data[firstNonWS]); firstNonWS++ {
-	}
-
-	for _, sig := range sniffSignatures {
-		if ct := sig.match(data, firstNonWS); ct != "" {
-			return ct
-		}
-	}
-
-	return "application/octet-stream" // fallback
-}
-
-// isWS reports whether the provided byte is a whitespace byte (0xWS)
-// as defined in https://mimesniff.spec.whatwg.org/#terminology.
-func isWS(b byte) bool {
-	switch b {
-	case '\t', '\n', '\x0c', '\r', ' ':
-		return true
-	}
-	return false
-}
-
-// isTT reports whether the provided byte is a tag-terminating byte (0xTT)
-// as defined in https://mimesniff.spec.whatwg.org/#terminology.
-func isTT(b byte) bool {
-	switch b {
-	case ' ', '>':
-		return true
-	}
-	return false
-}
-
-type sniffSig interface {
-	// match returns the MIME type of the data, or "" if unknown.
-	match(data []byte, firstNonWS int) string
-}
-
-// Data matching the table in section 6.
-var sniffSignatures = []sniffSig{
-	htmlSig("<!DOCTYPE HTML"),
-	htmlSig("<HTML"),
-	htmlSig("<HEAD"),
-	htmlSig("<SCRIPT"),
-	htmlSig("<IFRAME"),
-	htmlSig("<H1"),
-	htmlSig("<DIV"),
-	htmlSig("<FONT"),
-	htmlSig("<TABLE"),
-	htmlSig("<A"),
-	htmlSig("<STYLE"),
-	htmlSig("<TITLE"),
-	htmlSig("<B"),
-	htmlSig("<BODY"),
-	htmlSig("<BR"),
-	htmlSig("<P"),
-	htmlSig("<!--"),
-	&maskedSig{
-		mask:   []byte("\xFF\xFF\xFF\xFF\xFF"),
-		pat:    []byte("<?xml"),
-		skipWS: true,
-		ct:     "text/xml; charset=utf-8"},
-	&exactSig{[]byte("%PDF-"), "application/pdf"},
-	&exactSig{[]byte("%!PS-Adobe-"), "application/postscript"},
-
-	// UTF BOMs.
-	&maskedSig{
-		mask: []byte("\xFF\xFF\x00\x00"),
-		pat:  []byte("\xFE\xFF\x00\x00"),
-		ct:   "text/plain; charset=utf-16be",
-	},
-	&maskedSig{
-		mask: []byte("\xFF\xFF\x00\x00"),
-		pat:  []byte("\xFF\xFE\x00\x00"),
-		ct:   "text/plain; charset=utf-16le",
-	},
-	&maskedSig{
-		mask: []byte("\xFF\xFF\xFF\x00"),
-		pat:  []byte("\xEF\xBB\xBF\x00"),
-		ct:   "text/plain; charset=utf-8",
-	},
-
-	// Image types
-	// For posterity, we originally returned "image/vnd.microsoft.icon" from
-	// https://tools.ietf.org/html/draft-ietf-websec-mime-sniff-03#section-7
-	// https://codereview.appspot.com/4746042
-	// but that has since been replaced with "image/x-icon" in Section 6.2
-	// of https://mimesniff.spec.whatwg.org/#matching-an-image-type-pattern
-	&exactSig{[]byte("\x00\x00\x01\x00"), "image/x-icon"},
-	&exactSig{[]byte("\x00\x00\x02\x00"), "image/x-icon"},
-	&exactSig{[]byte("BM"), "image/bmp"},
-	&exactSig{[]byte("GIF87a"), "image/gif"},
-	&exactSig{[]byte("GIF89a"), "image/gif"},
-	&maskedSig{
-		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"),
-		pat:  []byte("RIFF\x00\x00\x00\x00WEBPVP"),
-		ct:   "image/webp",
-	},
-	&exactSig{[]byte("\x89PNG\x0D\x0A\x1A\x0A"), "image/png"},
-	&exactSig{[]byte("\xFF\xD8\xFF"), "image/jpeg"},
-
-	// Audio and Video types
-	// Enforce the pattern match ordering as prescribed in
-	// https://mimesniff.spec.whatwg.org/#matching-an-audio-or-video-type-pattern
-	&maskedSig{
-		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
-		pat:  []byte("FORM\x00\x00\x00\x00AIFF"),
-		ct:   "audio/aiff",
-	},
-	&maskedSig{
-		mask: []byte("\xFF\xFF\xFF"),
-		pat:  []byte("ID3"),
-		ct:   "audio/mpeg",
-	},
-	&maskedSig{
-		mask: []byte("\xFF\xFF\xFF\xFF\xFF"),
-		pat:  []byte("OggS\x00"),
-		ct:   "application/ogg",
-	},
-	&maskedSig{
-		mask: []byte("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
-		pat:  []byte("MThd\x00\x00\x00\x06"),
-		ct:   "audio/midi",
-	},
-	&maskedSig{
-		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
-		pat:  []byte("RIFF\x00\x00\x00\x00AVI "),
-		ct:   "video/avi",
-	},
-	&maskedSig{
-		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
-		pat:  []byte("RIFF\x00\x00\x00\x00WAVE"),
-		ct:   "audio/wave",
-	},
-	// 6.2.0.2. video/mp4
-	mp4Sig{},
-	// 6.2.0.3. video/webm
-	&exactSig{[]byte("\x1A\x45\xDF\xA3"), "video/webm"},
-
-	// Font types
-	&maskedSig{
-		// 34 NULL bytes followed by the string "LP"
-		pat: []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00LP"),
-		// 34 NULL bytes followed by \xF\xF
-		mask: []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF"),
-		ct:   "application/vnd.ms-fontobject",
-	},
-	&exactSig{[]byte("\x00\x01\x00\x00"), "font/ttf"},
-	&exactSig{[]byte("OTTO"), "font/otf"},
-	&exactSig{[]byte("ttcf"), "font/collection"},
-	&exactSig{[]byte("wOFF"), "font/woff"},
-	&exactSig{[]byte("wOF2"), "font/woff2"},
-
-	// Archive types
-	&exactSig{[]byte("\x1F\x8B\x08"), "application/x-gzip"},
-	&exactSig{[]byte("PK\x03\x04"), "application/zip"},
-	// RAR's signatures are incorrectly defined by the MIME spec as per
-	//    https://github.com/whatwg/mimesniff/issues/63
-	// However, RAR Labs correctly defines it at:
-	//    https://www.rarlab.com/technote.htm#rarsign
-	// so we use the definition from RAR Labs.
-	// TODO: do whatever the spec ends up doing.
-	&exactSig{[]byte("Rar!\x1A\x07\x00"), "application/x-rar-compressed"},     // RAR v1.5-v4.0
-	&exactSig{[]byte("Rar!\x1A\x07\x01\x00"), "application/x-rar-compressed"}, // RAR v5+
-
-	&exactSig{[]byte("\x00\x61\x73\x6D"), "application/wasm"},
-
-	textSig{}, // should be last
-}
-
-type exactSig struct {
-	sig []byte
-	ct  string
-}
-
-func (e *exactSig) match(data []byte, firstNonWS int) string {
-	if bytes.HasPrefix(data, e.sig) {
-		return e.ct
-	}
-	return ""
-}
-
-type maskedSig struct {
-	mask, pat []byte
-	skipWS    bool
-	ct        string
-}
-
-func (m *maskedSig) match(data []byte, firstNonWS int) string {
-	// pattern matching algorithm section 6
-	// https://mimesniff.spec.whatwg.org/#pattern-matching-algorithm
-
-	if m.skipWS {
-		data = data[firstNonWS:]
-	}
-	if len(m.pat) != len(m.mask) {
-		return ""
-	}
-	if len(data) < len(m.pat) {
-		return ""
-	}
-	for i, pb := range m.pat {
-		maskedData := data[i] & m.mask[i]
-		if maskedData != pb {
-			return ""
-		}
-	}
-	return m.ct
-}
-
-type htmlSig []byte
-
-func (h htmlSig) match(data []byte, firstNonWS int) string {
-	data = data[firstNonWS:]
-	if len(data) < len(h)+1 {
-		return ""
-	}
-	for i, b := range h {
-		db := data[i]
-		if 'A' <= b && b <= 'Z' {
-			db &= 0xDF
-		}
-		if b != db {
-			return ""
-		}
-	}
-	// Next byte must be a tag-terminating byte(0xTT).
-	if !isTT(data[len(h)]) {
-		return ""
-	}
-	return "text/html; charset=utf-8"
-}
-
-var mp4ftype = []byte("ftyp")
-var mp4 = []byte("mp4")
-
-type mp4Sig struct{}
-
-func (mp4Sig) match(data []byte, firstNonWS int) string {
-	// https://mimesniff.spec.whatwg.org/#signature-for-mp4
-	// c.f. section 6.2.1
-	if len(data) < 12 {
-		return ""
-	}
-	boxSize := int(binary.BigEndian.Uint32(data[:4]))
-	if len(data) < boxSize || boxSize%4 != 0 {
-		return ""
-	}
-	if !bytes.Equal(data[4:8], mp4ftype) {
-		return ""
-	}
-	for st := 8; st < boxSize; st += 4 {
-		if st == 12 {
-			// Ignores the four bytes that correspond to the version number of the "major brand".
-			continue
-		}
-		if bytes.Equal(data[st:st+3], mp4) {
-			return "video/mp4"
-		}
-	}
-	return ""
-}
-
-type textSig struct{}
-
-func (textSig) match(data []byte, firstNonWS int) string {
-	// c.f. section 5, step 4.
-	for _, b := range data[firstNonWS:] {
-		switch {
-		case b <= 0x08,
-			b == 0x0B,
-			0x0E <= b && b <= 0x1A,
-			0x1C <= b && b <= 0x1F:
-			return ""
-		}
-	}
-	return "text/plain; charset=utf-8"
+	return internal.DetectContentType(data)
 }

package/bin/go/src/net/http/transfer.go

@@ -12,6 +12,7 @@ import (
 	"internal/godebug"
 	"io"
 	"maps"
+	"math"
 	"net/http/httptrace"
 	"net/http/internal"
 	"net/http/internal/ascii"
@@ -146,6 +147,13 @@ func newTransferWriter(r any) (t *transferWriter, err error) {
 		t.Trailer = nil
 	}
 
+	// Validate Trailer names and values. The names are later written
+	// unmodified on the "Trailer:" line of the header, so invalid bytes
+	// (in particular CR and LF) would permit header injection. (Issue 78775.)
+	if err := validateHeaders(t.Trailer); err != "" {
+		return nil, fmt.Errorf("net/http: invalid trailer %s", err)
+	}
+
 	return t, nil
 }
 
@@ -488,7 +496,7 @@ func suppressedHeaders(status int) []string {
 }
 
 // msg is *Request or *Response.
-func readTransfer(msg any, r *bufio.Reader) (err error) {
+func readTransfer(msg any, r *bufio.Reader, maxTrailerHeaders int64) (err error) {
 	t := &transferReader{RequestMethod: "GET"}
 
 	// Unify input
@@ -542,7 +550,7 @@ func readTransfer(msg any, r *bufio.Reader) (err error) {
 	}
 
 	// Trailer
-	t.Trailer, err = fixTrailer(t.Header, t.Chunked)
+	t.Trailer, err = fixTrailer(t.Header, t.Chunked, maxTrailerHeaders)
 	if err != nil {
 		return err
 	}
@@ -565,7 +573,7 @@ func readTransfer(msg any, r *bufio.Reader) (err error) {
 		if isResponse && (noResponseBodyExpected(t.RequestMethod) || !bodyAllowedForStatus(t.StatusCode)) {
 			t.Body = NoBody
 		} else {
-			t.Body = &body{src: internal.NewChunkedReader(r), hdr: msg, r: r, closing: t.Close}
+			t.Body = &body{src: internal.NewChunkedReader(r), hdr: msg, r: r, closing: t.Close, maxTrailerHeaders: maxTrailerHeaders}
 		}
 	case realLength == 0:
 		t.Body = NoBody
@@ -764,7 +772,7 @@ func shouldClose(major, minor int, header Header, removeCloseHeader bool) bool {
 }
 
 // Parse the trailer header.
-func fixTrailer(header Header, chunked bool) (Header, error) {
+func fixTrailer(header Header, chunked bool, maxHeaders int64) (Header, error) {
 	vv, ok := header["Trailer"]
 	if !ok {
 		return nil, nil
@@ -780,6 +788,12 @@ func fixTrailer(header Header, chunked bool) (Header, error) {
 		return nil, nil
 	}
 	header.Del("Trailer")
+	for _, v := range vv {
+		maxHeaders -= int64(strings.Count(v, ",") + 1)
+		if maxHeaders < 0 {
+			return nil, errTooLarge
+		}
+	}
 
 	trailer := make(Header)
 	var err error
@@ -809,17 +823,19 @@ func fixTrailer(header Header, chunked bool) (Header, error) {
 // Close ensures that the body has been fully read
 // and then reads the trailer if necessary.
 type body struct {
-	src          io.Reader
-	hdr          any           // non-nil (Response or Request) value means read trailer
-	r            *bufio.Reader // underlying wire-format reader for the trailer
-	closing      bool          // is the connection to be closed after reading body?
-	doEarlyClose bool          // whether Close should stop early
-
-	mu         sync.Mutex // guards following, and calls to Read and Close
-	sawEOF     bool
-	closed     bool
-	earlyClose bool   // Close called and we didn't read to the end of src
-	onHitEOF   func() // if non-nil, func to call when EOF is Read
+	src               io.Reader
+	hdr               any           // non-nil (Response or Request) value means read trailer
+	r                 *bufio.Reader // underlying wire-format reader for the trailer
+	closing           bool          // is the connection to be closed after reading body?
+	doEarlyClose      bool          // whether Close should stop early
+	maxTrailerHeaders int64         // how many trailer header values are allowed
+
+	mu          sync.Mutex // guards following, and calls to Read and Close
+	sawEOF      bool
+	closed      bool
+	earlyClose  bool   // Close called and we didn't read to the end of src
+	dropTrailer bool   // if true, do not populate hdr.Trailer
+	onHitEOF    func() // if non-nil, func to call when EOF is Read
 }
 
 // ErrBodyReadAfterClose is returned when reading a [Request] or [Response]
@@ -829,6 +845,9 @@ type body struct {
 var ErrBodyReadAfterClose = errors.New("http: invalid Read on closed Body")
 
 func (b *body) Read(p []byte) (n int, err error) {
+	if b == nil {
+		return 0, io.EOF
+	}
 	b.mu.Lock()
 	defer b.mu.Unlock()
 	if b.closed {
@@ -934,13 +953,20 @@ func (b *body) readTrailer() error {
 		return errors.New("http: suspiciously long trailer after chunked body")
 	}
 
-	hdr, err := textproto.NewReader(b.r).ReadMIMEHeader()
+	hdr, err := readMIMEHeader(textproto.NewReader(b.r), math.MaxInt64, b.maxTrailerHeaders)
 	if err != nil {
 		if err == io.EOF {
 			return errTrailerEOF
 		}
 		return err
 	}
+	// When we are automatically draining a response body, let the trailer
+	// still be parsed above (so connection can be reused). However, do not
+	// actually populate b.hdr.Trailer. Doing so is racy as we do not own b.hdr
+	// anymore when automatic draining occurs.
+	if b.dropTrailer {
+		return nil
+	}
 	switch rr := b.hdr.(type) {
 	case *Request:
 		mergeSetHeader(&rr.Trailer, Header(hdr))
@@ -958,6 +984,12 @@ func mergeSetHeader(dst *Header, src Header) {
 	maps.Copy(*dst, src)
 }
 
+func (b *body) discardTrailer() {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.dropTrailer = true
+}
+
 // unreadDataSizeLocked returns the number of bytes of unread input.
 // It returns -1 if unknown.
 // b.mu must be held.
@@ -969,6 +1001,9 @@ func (b *body) unreadDataSizeLocked() int64 {
 }
 
 func (b *body) Close() error {
+	if b == nil {
+		return nil
+	}
 	b.mu.Lock()
 	defer b.mu.Unlock()
 	if b.closed {
@@ -992,13 +1027,15 @@ func (b *body) Close() error {
 			var n int64
 			// Consume the body, or, which will also lead to us reading
 			// the trailer headers after the body, if present.
-			n, err = io.CopyN(io.Discard, bodyLocked{b}, maxPostHandlerReadBytes)
-			if err == io.EOF {
+			n, err = io.CopyN(io.Discard, bodyLocked{b}, maxPostHandlerReadBytes+1)
+			b.earlyClose = true
+			if err == io.EOF && n <= maxPostHandlerReadBytes {
+				b.earlyClose = false
+				b.sawEOF = true
+				// Reaching the end of the body is the expected
+				// outcome here, not an error to report to the caller.
 				err = nil
 			}
-			if n == maxPostHandlerReadBytes {
-				b.earlyClose = true
-			}
 		}
 	default:
 		// Fully consume the body, which will also lead to us reading
@@ -1018,12 +1055,18 @@ func (b *body) didEarlyClose() bool {
 // bodyRemains reports whether future Read calls might
 // yield data.
 func (b *body) bodyRemains() bool {
+	if b == nil {
+		return false
+	}
 	b.mu.Lock()
 	defer b.mu.Unlock()
 	return !b.sawEOF
 }
 
 func (b *body) registerOnHitEOF(fn func()) {
+	if b == nil {
+		return
+	}
 	b.mu.Lock()
 	defer b.mu.Unlock()
 	b.onHitEOF = fn