if len(contentUrl) >= 2 && (contentUrl[0] == byte('\'') || contentUrl[0] == byte('"')) {
if contentUrl[0] == contentUrl[len(contentUrl)-1] {
contentUrl = contentUrl[1 : len(contentUrl)-1]
}
}
// output proxify result
if uri, err := rc.ProxifyURI(contentUrl); err == nil {
fmt.Fprintf(out, ` http-equiv="refresh" content="%surl=%s"`, content[:urlIndex], uri)
}
} else {
if len(http_equiv) > 0 {
fmt.Fprintf(out, ` http-equiv="%s"`, http_equiv)
}
sanitizeAttrs(rc, out, attrs)
}
out.Write([]byte(">"))
}
func sanitizeAttrs(rc *RequestConfig, out io.Writer, attrs [][][]byte) {
for _, attr := range attrs {
sanitizeAttr(rc, out, attr[0], attr[1], attr[2])
}
}
func sanitizeAttr(rc *RequestConfig, out io.Writer, attrName, attrValue, escapedAttrValue []byte) {
if inArray(attrName, SAFE_ATTRIBUTES) {
fmt.Fprintf(out, " %s=\"%s\"", attrName, escapedAttrValue)
return
}
switch string(attrName) {
case "src", "href", "action":
if uri, err := rc.ProxifyURI(attrValue); err == nil {
fmt.Fprintf(out, " %s=\"%s\"", attrName, uri)
} else {
log.Println("cannot proxify uri:", string(attrValue))
}
case "style":
cssAttr := bytes.NewBuffer(nil)
sanitizeCSS(rc, cssAttr, attrValue)
fmt.Fprintf(out, " %s=\"%s\"", attrName, html.EscapeString(string(cssAttr.Bytes())))
}
}
func mergeURIs(u1, u2 *url.URL) *url.URL {
return u1.ResolveReference(u2)
}
// Sanitized URI : removes all runes bellow 32 (included) as the begining and end of URI, and lower case the scheme.
// avoid memory allocation (except for the scheme)
func sanitizeURI(uri []byte) ([]byte, string) {
first_rune_index := 0
first_rune_seen := false
scheme_last_index := -1
buffer := bytes.NewBuffer(make([]byte, 0, 10))
// remove trailing space and special characters
uri = bytes.TrimRight(uri, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x20")
// loop over byte by byte
for i, c := range uri {
// ignore special characters and space (c <= 32)
if c > 32 {
// append to the lower case of the rune to buffer
if c < utf8.RuneSelf && 'A' <= c && c <= 'Z' {
c = c + 'a' - 'A'
}
buffer.WriteByte(c)
// update the first rune index that is not a special rune
if !first_rune_seen {
first_rune_index = i
first_rune_seen = true
}
if c == ':' {
// colon rune found, we have found the scheme
scheme_last_index = i
break
} else if c == '/' || c == '?' || c == '\\' || c == '#' {
// special case : most probably a relative URI
break
}
}
}
if scheme_last_index != -1 {
// scheme found
// copy the "lower case without special runes scheme" before the ":" rune
scheme_start_index := scheme_last_index - buffer.Len() + 1
copy(uri[scheme_start_index:], buffer.Bytes())
// and return the result
return uri[scheme_start_index:], buffer.String()
} else {
// scheme NOT found
return uri[first_rune_index:], ""
}
}
func (rc *RequestConfig) ProxifyURI(uri []byte) (string, error) {
// sanitize URI
uri, scheme := sanitizeURI(uri)
// remove javascript protocol
if scheme == "javascript:" {
return "", nil
}
// TODO check malicious data: - e.g. data:script
if scheme == "data:" {
if bytes.HasPrefix(uri, []byte("data:image/png")) ||
bytes.HasPrefix(uri, []byte("data:image/jpeg")) ||
bytes.HasPrefix(uri, []byte("data:image/pjpeg")) ||
bytes.HasPrefix(uri, []byte("data:image/gif")) ||
bytes.HasPrefix(uri, []byte("data:image/webp")) {
// should be safe
return string(uri), nil
} else {
// unsafe data
return "", nil
}
}
// parse the uri
u, err := url.Parse(string(uri))
if err != nil {
return "", err
}
// get the fragment (with the prefix "#")
fragment := ""
if len(u.Fragment) > 0 {
fragment = "#" + u.Fragment
}
// reset the fragment: it is not included in the mortyurl
u.Fragment = ""
// merge the URI with the document URI
u = mergeURIs(rc.BaseURL, u)
// simple internal link ?
// some web pages describe the whole link https://same:auth@same.host/same.path?same.query#new.fragment
if u.Scheme == rc.BaseURL.Scheme &&
(rc.BaseURL.User == nil || (u.User != nil && u.User.String() == rc.BaseURL.User.String())) &&
u.Host == rc.BaseURL.Host &&
u.Path == rc.BaseURL.Path &&
u.RawQuery == rc.BaseURL.RawQuery {
// the fragment is the only difference between the document URI and the uri parameter
return fragment, nil
}
// return full URI and fragment (if not empty)
morty_uri := u.String()
if rc.Key == nil {
return fmt.Sprintf("./?mortyurl=%s%s", url.QueryEscape(morty_uri), fragment), nil
}
return fmt.Sprintf("./?mortyhash=%s&mortyurl=%s%s", hash(morty_uri, rc.Key), url.QueryEscape(morty_uri), fragment), nil
}
func inArray(b []byte, a [][]byte) bool {
for _, b2 := range a {
if bytes.Equal(b, b2) {
return true
}
}
return false
}
func hash(msg string, key []byte) string {
mac := hmac.New(sha256.New, key)
mac.Write([]byte(msg))
return hex.EncodeToString(mac.Sum(nil))
}
func verifyRequestURI(uri, hashMsg, key []byte) bool {
h := make([]byte, hex.DecodedLen(len(hashMsg)))
_, err := hex.Decode(h, hashMsg)
if err != nil {
log.Println("hmac error:", err)
return false
}
mac := hmac.New(sha256.New, key)
mac.Write(uri)
return hmac.Equal(h, mac.Sum(nil))
}
func (p *Proxy) serveMainPage(ctx *fasthttp.RequestCtx, statusCode int, err error) {
ctx.SetContentType("text/html")
ctx.SetStatusCode(statusCode)
ctx.Write([]byte(`
MortyProxy
MortyProxy
`))
if err != nil {
log.Println("error:", err)
ctx.Write([]byte("Error: "))
ctx.Write([]byte(html.EscapeString(err.Error())))
ctx.Write([]byte("
"))
}
if p.Key == nil {
ctx.Write([]byte(`
`))
} else {
ctx.Write([]byte(`Warning! This instance does not support direct URL opening.
`))
}
ctx.Write([]byte(`