libgo/go/net/http/sniff.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package http
   6
   7 import (
   8         "bytes"
   9         "encoding/binary"
  10 )
  11
  12 // The algorithm uses at most sniffLen bytes to make its decision.
  13 const sniffLen = 512
  14
  15 // DetectContentType implements the algorithm described
  16 // at https://mimesniff.spec.whatwg.org/ to determine the
  17 // Content-Type of the given data. It considers at most the
  18 // first 512 bytes of data. DetectContentType always returns
  19 // a valid MIME type: if it cannot determine a more specific one, it
  20 // returns "application/octet-stream".
  21 func DetectContentType(data []byte) string {
  22         if len(data) > sniffLen {
  23                 data = data[:sniffLen]
  24         }
  25
  26         // Index of the first non-whitespace byte in data.
  27         firstNonWS := 0
  28         for ; firstNonWS < len(data) && isWS(data[firstNonWS]); firstNonWS++ {
  29         }
  30
  31         for _, sig := range sniffSignatures {
  32                 if ct := sig.match(data, firstNonWS); ct != "" {
  33                         return ct
  34                 }
  35         }
  36
  37         return "application/octet-stream" // fallback
  38 }
  39
  40 // isWS reports whether the provided byte is a whitespace byte (0xWS)
  41 // as defined in https://mimesniff.spec.whatwg.org/#terminology.
  42 func isWS(b byte) bool {
  43         switch b {
  44         case '\t', '\n', '\x0c', '\r', ' ':
  45                 return true
  46         }
  47         return false
  48 }
  49
  50 // isTT reports whether the provided byte is a tag-terminating byte (0xTT)
  51 // as defined in https://mimesniff.spec.whatwg.org/#terminology.
  52 func isTT(b byte) bool {
  53         switch b {
  54         case ' ', '>':
  55                 return true
  56         }
  57         return false
  58 }
  59
  60 type sniffSig interface {
  61         // match returns the MIME type of the data, or "" if unknown.
  62         match(data []byte, firstNonWS int) string
  63 }
  64
  65 // Data matching the table in section 6.
  66 var sniffSignatures = []sniffSig{
  67         htmlSig("<!DOCTYPE HTML"),
  68         htmlSig("<HTML"),
  69         htmlSig("<HEAD"),
  70         htmlSig("<SCRIPT"),
  71         htmlSig("<IFRAME"),
  72         htmlSig("<H1"),
  73         htmlSig("<DIV"),
  74         htmlSig("<FONT"),
  75         htmlSig("<TABLE"),
  76         htmlSig("<A"),
  77         htmlSig("<STYLE"),
  78         htmlSig("<TITLE"),
  79         htmlSig("<B"),
  80         htmlSig("<BODY"),
  81         htmlSig("<BR"),
  82         htmlSig("<P"),
  83         htmlSig("<!--"),
  84         &maskedSig{
  85                 mask:   []byte("\xFF\xFF\xFF\xFF\xFF"),
  86                 pat:    []byte("<?xml"),
  87                 skipWS: true,
  88                 ct:     "text/xml; charset=utf-8"},
  89         &exactSig{[]byte("%PDF-"), "application/pdf"},
  90         &exactSig{[]byte("%!PS-Adobe-"), "application/postscript"},
  91
  92         // UTF BOMs.
  93         &maskedSig{
  94                 mask: []byte("\xFF\xFF\x00\x00"),
  95                 pat:  []byte("\xFE\xFF\x00\x00"),
  96                 ct:   "text/plain; charset=utf-16be",
  97         },
  98         &maskedSig{
  99                 mask: []byte("\xFF\xFF\x00\x00"),
 100                 pat:  []byte("\xFF\xFE\x00\x00"),
 101                 ct:   "text/plain; charset=utf-16le",
 102         },
 103         &maskedSig{
 104                 mask: []byte("\xFF\xFF\xFF\x00"),
 105                 pat:  []byte("\xEF\xBB\xBF\x00"),
 106                 ct:   "text/plain; charset=utf-8",
 107         },
 108
 109         // Image types
 110         // For posterity, we originally returned "image/vnd.microsoft.icon" from
 111         // https://tools.ietf.org/html/draft-ietf-websec-mime-sniff-03#section-7
 112         // https://codereview.appspot.com/4746042
 113         // but that has since been replaced with "image/x-icon" in Section 6.2
 114         // of https://mimesniff.spec.whatwg.org/#matching-an-image-type-pattern
 115         &exactSig{[]byte("\x00\x00\x01\x00"), "image/x-icon"},
 116         &exactSig{[]byte("\x00\x00\x02\x00"), "image/x-icon"},
 117         &exactSig{[]byte("BM"), "image/bmp"},
 118         &exactSig{[]byte("GIF87a"), "image/gif"},
 119         &exactSig{[]byte("GIF89a"), "image/gif"},
 120         &maskedSig{
 121                 mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"),
 122                 pat:  []byte("RIFF\x00\x00\x00\x00WEBPVP"),
 123                 ct:   "image/webp",
 124         },
 125         &exactSig{[]byte("\x89PNG\x0D\x0A\x1A\x0A"), "image/png"},
 126         &exactSig{[]byte("\xFF\xD8\xFF"), "image/jpeg"},
 127
 128         // Audio and Video types
 129         // Enforce the pattern match ordering as prescribed in
 130         // https://mimesniff.spec.whatwg.org/#matching-an-audio-or-video-type-pattern
 131         &maskedSig{
 132                 mask: []byte("\xFF\xFF\xFF\xFF"),
 133                 pat:  []byte(".snd"),
 134                 ct:   "audio/basic",
 135         },
 136         &maskedSig{
 137                 mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
 138                 pat:  []byte("FORM\x00\x00\x00\x00AIFF"),
 139                 ct:   "audio/aiff",
 140         },
 141         &maskedSig{
 142                 mask: []byte("\xFF\xFF\xFF"),
 143                 pat:  []byte("ID3"),
 144                 ct:   "audio/mpeg",
 145         },
 146         &maskedSig{
 147                 mask: []byte("\xFF\xFF\xFF\xFF\xFF"),
 148                 pat:  []byte("OggS\x00"),
 149                 ct:   "application/ogg",
 150         },
 151         &maskedSig{
 152                 mask: []byte("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
 153                 pat:  []byte("MThd\x00\x00\x00\x06"),
 154                 ct:   "audio/midi",
 155         },
 156         &maskedSig{
 157                 mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
 158                 pat:  []byte("RIFF\x00\x00\x00\x00AVI "),
 159                 ct:   "video/avi",
 160         },
 161         &maskedSig{
 162                 mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
 163                 pat:  []byte("RIFF\x00\x00\x00\x00WAVE"),
 164                 ct:   "audio/wave",
 165         },
 166         // 6.2.0.2. video/mp4
 167         mp4Sig{},
 168         // 6.2.0.3. video/webm
 169         &exactSig{[]byte("\x1A\x45\xDF\xA3"), "video/webm"},
 170
 171         // Font types
 172         &maskedSig{
 173                 // 34 NULL bytes followed by the string "LP"
 174                 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"),
 175                 // 34 NULL bytes followed by \xF\xF
 176                 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"),
 177                 ct:   "application/vnd.ms-fontobject",
 178         },
 179         &exactSig{[]byte("\x00\x01\x00\x00"), "font/ttf"},
 180         &exactSig{[]byte("OTTO"), "font/otf"},
 181         &exactSig{[]byte("ttcf"), "font/collection"},
 182         &exactSig{[]byte("wOFF"), "font/woff"},
 183         &exactSig{[]byte("wOF2"), "font/woff2"},
 184
 185         // Archive types
 186         &exactSig{[]byte("\x1F\x8B\x08"), "application/x-gzip"},
 187         &exactSig{[]byte("PK\x03\x04"), "application/zip"},
 188         // RAR's signatures are incorrectly defined by the MIME spec as per
 189         //    https://github.com/whatwg/mimesniff/issues/63
 190         // However, RAR Labs correctly defines it at:
 191         //    https://www.rarlab.com/technote.htm#rarsign
 192         // so we use the definition from RAR Labs.
 193         // TODO: do whatever the spec ends up doing.
 194         &exactSig{[]byte("Rar!\x1A\x07\x00"), "application/x-rar-compressed"},     // RAR v1.5-v4.0
 195         &exactSig{[]byte("Rar!\x1A\x07\x01\x00"), "application/x-rar-compressed"}, // RAR v5+
 196
 197         &exactSig{[]byte("\x00\x61\x73\x6D"), "application/wasm"},
 198
 199         textSig{}, // should be last
 200 }
 201
 202 type exactSig struct {
 203         sig []byte
 204         ct  string
 205 }
 206
 207 func (e *exactSig) match(data []byte, firstNonWS int) string {
 208         if bytes.HasPrefix(data, e.sig) {
 209                 return e.ct
 210         }
 211         return ""
 212 }
 213
 214 type maskedSig struct {
 215         mask, pat []byte
 216         skipWS    bool
 217         ct        string
 218 }
 219
 220 func (m *maskedSig) match(data []byte, firstNonWS int) string {
 221         // pattern matching algorithm section 6
 222         // https://mimesniff.spec.whatwg.org/#pattern-matching-algorithm
 223
 224         if m.skipWS {
 225                 data = data[firstNonWS:]
 226         }
 227         if len(m.pat) != len(m.mask) {
 228                 return ""
 229         }
 230         if len(data) < len(m.pat) {
 231                 return ""
 232         }
 233         for i, pb := range m.pat {
 234                 maskedData := data[i] & m.mask[i]
 235                 if maskedData != pb {
 236                         return ""
 237                 }
 238         }
 239         return m.ct
 240 }
 241
 242 type htmlSig []byte
 243
 244 func (h htmlSig) match(data []byte, firstNonWS int) string {
 245         data = data[firstNonWS:]
 246         if len(data) < len(h)+1 {
 247                 return ""
 248         }
 249         for i, b := range h {
 250                 db := data[i]
 251                 if 'A' <= b && b <= 'Z' {
 252                         db &= 0xDF
 253                 }
 254                 if b != db {
 255                         return ""
 256                 }
 257         }
 258         // Next byte must be a tag-terminating byte(0xTT).
 259         if !isTT(data[len(h)]) {
 260                 return ""
 261         }
 262         return "text/html; charset=utf-8"
 263 }
 264
 265 var mp4ftype = []byte("ftyp")
 266 var mp4 = []byte("mp4")
 267
 268 type mp4Sig struct{}
 269
 270 func (mp4Sig) match(data []byte, firstNonWS int) string {
 271         // https://mimesniff.spec.whatwg.org/#signature-for-mp4
 272         // c.f. section 6.2.1
 273         if len(data) < 12 {
 274                 return ""
 275         }
 276         boxSize := int(binary.BigEndian.Uint32(data[:4]))
 277         if len(data) < boxSize || boxSize%4 != 0 {
 278                 return ""
 279         }
 280         if !bytes.Equal(data[4:8], mp4ftype) {
 281                 return ""
 282         }
 283         for st := 8; st < boxSize; st += 4 {
 284                 if st == 12 {
 285                         // Ignores the four bytes that correspond to the version number of the "major brand".
 286                         continue
 287                 }
 288                 if bytes.Equal(data[st:st+3], mp4) {
 289                         return "video/mp4"
 290                 }
 291         }
 292         return ""
 293 }
 294
 295 type textSig struct{}
 296
 297 func (textSig) match(data []byte, firstNonWS int) string {
 298         // c.f. section 5, step 4.
 299         for _, b := range data[firstNonWS:] {
 300                 switch {
 301                 case b <= 0x08,
 302                         b == 0x0B,
 303                         0x0E <= b && b <= 0x1A,
 304                         0x1C <= b && b <= 0x1F:
 305                         return ""
 306                 }
 307         }
 308         return "text/plain; charset=utf-8"
 309 }