sniff.go

Documentation: net/http

     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  func isWS(b byte) bool {
    41  	switch b {
    42  	case '\t', '\n', '\x0c', '\r', ' ':
    43  		return true
    44  	}
    45  	return false
    46  }
    47  
    48  type sniffSig interface {
    49  	// match returns the MIME type of the data, or "" if unknown.
    50  	match(data []byte, firstNonWS int) string
    51  }
    52  
    53  // Data matching the table in section 6.
    54  var sniffSignatures = []sniffSig{
    55  	htmlSig("<!DOCTYPE HTML"),
    56  	htmlSig("<HTML"),
    57  	htmlSig("<HEAD"),
    58  	htmlSig("<SCRIPT"),
    59  	htmlSig("<IFRAME"),
    60  	htmlSig("<H1"),
    61  	htmlSig("<DIV"),
    62  	htmlSig("<FONT"),
    63  	htmlSig("<TABLE"),
    64  	htmlSig("<A"),
    65  	htmlSig("<STYLE"),
    66  	htmlSig("<TITLE"),
    67  	htmlSig("<B"),
    68  	htmlSig("<BODY"),
    69  	htmlSig("<BR"),
    70  	htmlSig("<P"),
    71  	htmlSig("<!--"),
    72  
    73  	&maskedSig{mask: []byte("\xFF\xFF\xFF\xFF\xFF"), pat: []byte("<?xml"), skipWS: true, ct: "text/xml; charset=utf-8"},
    74  
    75  	&exactSig{[]byte("%PDF-"), "application/pdf"},
    76  	&exactSig{[]byte("%!PS-Adobe-"), "application/postscript"},
    77  
    78  	// UTF BOMs.
    79  	&maskedSig{mask: []byte("\xFF\xFF\x00\x00"), pat: []byte("\xFE\xFF\x00\x00"), ct: "text/plain; charset=utf-16be"},
    80  	&maskedSig{mask: []byte("\xFF\xFF\x00\x00"), pat: []byte("\xFF\xFE\x00\x00"), ct: "text/plain; charset=utf-16le"},
    81  	&maskedSig{mask: []byte("\xFF\xFF\xFF\x00"), pat: []byte("\xEF\xBB\xBF\x00"), ct: "text/plain; charset=utf-8"},
    82  
    83  	&exactSig{[]byte("GIF87a"), "image/gif"},
    84  	&exactSig{[]byte("GIF89a"), "image/gif"},
    85  	&exactSig{[]byte("\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"), "image/png"},
    86  	&exactSig{[]byte("\xFF\xD8\xFF"), "image/jpeg"},
    87  	&exactSig{[]byte("BM"), "image/bmp"},
    88  	&maskedSig{
    89  		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"),
    90  		pat:  []byte("RIFF\x00\x00\x00\x00WEBPVP"),
    91  		ct:   "image/webp",
    92  	},
    93  	&exactSig{[]byte("\x00\x00\x01\x00"), "image/vnd.microsoft.icon"},
    94  
    95  	&maskedSig{
    96  		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
    97  		pat:  []byte("RIFF\x00\x00\x00\x00WAVE"),
    98  		ct:   "audio/wave",
    99  	},
   100  	&maskedSig{
   101  		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
   102  		pat:  []byte("FORM\x00\x00\x00\x00AIFF"),
   103  		ct:   "audio/aiff",
   104  	},
   105  	&maskedSig{
   106  		mask: []byte("\xFF\xFF\xFF\xFF"),
   107  		pat:  []byte(".snd"),
   108  		ct:   "audio/basic",
   109  	},
   110  	&maskedSig{
   111  		mask: []byte("\xFF\xFF\xFF\xFF\xFF"),
   112  		pat:  []byte("OggS\x00"),
   113  		ct:   "application/ogg",
   114  	},
   115  	&maskedSig{
   116  		mask: []byte("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
   117  		pat:  []byte("MThd\x00\x00\x00\x06"),
   118  		ct:   "audio/midi",
   119  	},
   120  	&maskedSig{
   121  		mask: []byte("\xFF\xFF\xFF"),
   122  		pat:  []byte("ID3"),
   123  		ct:   "audio/mpeg",
   124  	},
   125  	&maskedSig{
   126  		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
   127  		pat:  []byte("RIFF\x00\x00\x00\x00AVI "),
   128  		ct:   "video/avi",
   129  	},
   130  
   131  	// Fonts
   132  	&maskedSig{
   133  		// 34 NULL bytes followed by the string "LP"
   134  		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\x00\x4C\x50"),
   135  		// 34 NULL bytes followed by \xF\xF
   136  		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"),
   137  		ct:   "application/vnd.ms-fontobject",
   138  	},
   139  	&exactSig{[]byte("\x00\x01\x00\x00"), "font/ttf"},
   140  	&exactSig{[]byte("OTTO"), "font/otf"},
   141  	&exactSig{[]byte("ttcf"), "font/collection"},
   142  	&exactSig{[]byte("wOFF"), "font/woff"},
   143  	&exactSig{[]byte("wOF2"), "font/woff2"},
   144  
   145  	&exactSig{[]byte("\x1A\x45\xDF\xA3"), "video/webm"},
   146  	&exactSig{[]byte("\x52\x61\x72\x20\x1A\x07\x00"), "application/x-rar-compressed"},
   147  	&exactSig{[]byte("\x50\x4B\x03\x04"), "application/zip"},
   148  	&exactSig{[]byte("\x1F\x8B\x08"), "application/x-gzip"},
   149  
   150  	&exactSig{[]byte("\x00\x61\x73\x6D"), "application/wasm"},
   151  
   152  	mp4Sig{},
   153  
   154  	textSig{}, // should be last
   155  }
   156  
   157  type exactSig struct {
   158  	sig []byte
   159  	ct  string
   160  }
   161  
   162  func (e *exactSig) match(data []byte, firstNonWS int) string {
   163  	if bytes.HasPrefix(data, e.sig) {
   164  		return e.ct
   165  	}
   166  	return ""
   167  }
   168  
   169  type maskedSig struct {
   170  	mask, pat []byte
   171  	skipWS    bool
   172  	ct        string
   173  }
   174  
   175  func (m *maskedSig) match(data []byte, firstNonWS int) string {
   176  	// pattern matching algorithm section 6
   177  	// https://mimesniff.spec.whatwg.org/#pattern-matching-algorithm
   178  
   179  	if m.skipWS {
   180  		data = data[firstNonWS:]
   181  	}
   182  	if len(m.pat) != len(m.mask) {
   183  		return ""
   184  	}
   185  	if len(data) < len(m.mask) {
   186  		return ""
   187  	}
   188  	for i, mask := range m.mask {
   189  		db := data[i] & mask
   190  		if db != m.pat[i] {
   191  			return ""
   192  		}
   193  	}
   194  	return m.ct
   195  }
   196  
   197  type htmlSig []byte
   198  
   199  func (h htmlSig) match(data []byte, firstNonWS int) string {
   200  	data = data[firstNonWS:]
   201  	if len(data) < len(h)+1 {
   202  		return ""
   203  	}
   204  	for i, b := range h {
   205  		db := data[i]
   206  		if 'A' <= b && b <= 'Z' {
   207  			db &= 0xDF
   208  		}
   209  		if b != db {
   210  			return ""
   211  		}
   212  	}
   213  	// Next byte must be space or right angle bracket.
   214  	if db := data[len(h)]; db != ' ' && db != '>' {
   215  		return ""
   216  	}
   217  	return "text/html; charset=utf-8"
   218  }
   219  
   220  var mp4ftype = []byte("ftyp")
   221  var mp4 = []byte("mp4")
   222  
   223  type mp4Sig struct{}
   224  
   225  func (mp4Sig) match(data []byte, firstNonWS int) string {
   226  	// https://mimesniff.spec.whatwg.org/#signature-for-mp4
   227  	// c.f. section 6.2.1
   228  	if len(data) < 12 {
   229  		return ""
   230  	}
   231  	boxSize := int(binary.BigEndian.Uint32(data[:4]))
   232  	if boxSize%4 != 0 || len(data) < boxSize {
   233  		return ""
   234  	}
   235  	if !bytes.Equal(data[4:8], mp4ftype) {
   236  		return ""
   237  	}
   238  	for st := 8; st < boxSize; st += 4 {
   239  		if st == 12 {
   240  			// minor version number
   241  			continue
   242  		}
   243  		if bytes.Equal(data[st:st+3], mp4) {
   244  			return "video/mp4"
   245  		}
   246  	}
   247  	return ""
   248  }
   249  
   250  type textSig struct{}
   251  
   252  func (textSig) match(data []byte, firstNonWS int) string {
   253  	// c.f. section 5, step 4.
   254  	for _, b := range data[firstNonWS:] {
   255  		switch {
   256  		case b <= 0x08,
   257  			b == 0x0B,
   258  			0x0E <= b && b <= 0x1A,
   259  			0x1C <= b && b <= 0x1F:
   260  			return ""
   261  		}
   262  	}
   263  	return "text/plain; charset=utf-8"
   264  }
   265
View as plain text