Add files via upload

README.md

@@ -1 +1 @@
-# webproxy
+# webproxy

mainproxy.go

@@ -0,0 +1,250 @@
+package main
+
+import (
+	"encoding/base64"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"path"
+	"regexp"
+	"strings"
+)
+
+func marshalURL(urlp *url.URL) string {
+	return base64.URLEncoding.EncodeToString([]byte(urlp.String()))
+}
+
+func unmarshalURL(s string) *url.URL {
+	byteURL, err := base64.URLEncoding.DecodeString(s)
+	if err != nil {
+		log.Fatal(err)
+	}
+	urlp, err := url.Parse(string(byteURL))
+	if err != nil {
+		log.Fatal(err)
+	}
+	return urlp
+}
+
+//fai diventare una url relativa in assoluta
+func sanitizeURL(urlToSanitize *url.URL, currentURLp *url.URL) url.URL {
+
+	sanitizedURL := *urlToSanitize
+
+	// se non c'era host, imposto quello corrente
+	if sanitizedURL.Host == "" {
+		sanitizedURL.Host = currentURLp.Host
+	}
+
+	// se non c'era scheme, imposto quella corrente
+	if sanitizedURL.Scheme == "" {
+		sanitizedURL.Scheme = currentURLp.Scheme
+	}
+
+	// pulisci la path, assumi che la url corrente sia SEMPRE assoluta
+	if sanitizedURL.Path != "" && !path.IsAbs(sanitizedURL.Path) {
+		sanitizedURL.Path = path.Clean(path.Join("/", path.Dir(currentURLp.Path), sanitizedURL.Path))
+	}
+
+	return sanitizedURL
+}
+
+func replaceURLhtml(urlString string, element string, currentURLp *url.URL) string {
+
+	//log.Println("url da riscrivere: " + urlString)
+	//prendo la vera url, go non ha lookahead, stronzi
+	//devo inoltre preservare i quote
+	//log.Println("prima prima: " + urlString)
+	newurlString := urlString
+	quote := ""
+	if strings.Contains(newurlString, `"`) {
+		newurlString = strings.Replace(newurlString, `"`, ``, -1)
+		quote = `"`
+	}
+	if strings.Contains(newurlString, `'`) {
+		newurlString = strings.Replace(newurlString, `'`, ``, -1)
+		quote = `'`
+	}
+
+	newurlString = strings.Replace(newurlString, element, ``, -1)
+	newurlString = strings.Replace(newurlString, ` `, ``, -1) //nuovo, non sono sicurox
+
+	//log.Println("prima: " + newurlString)
+
+	//ora la parso e inserisco delle info di controno, poi la serializzo e ritorno questa nuova url
+
+	urlp, err := url.Parse(newurlString)
+	if err != nil {
+		//log.Println("ignoro url che non ho potuto parsare:")
+		//log.Println(err)
+		return urlString
+	}
+
+	//i fragment non devono essere inclusi nel marshal, tanto non sono passati via http
+	fragment := ""
+	if urlp.Fragment != "" {
+		fragment = "#" + urlp.Fragment
+		urlp.Fragment = ""
+	}
+
+	// certe volte arrivano vuote, in quel caso metti solo il fragment
+	if urlp.Path == "" && urlp.Host == "" {
+		return element + quote + fragment + quote
+	}
+
+	//ora ho una url ma potrebbe avere path relativo, devo farlo assoluto
+	newURL := sanitizeURL(urlp, currentURLp)
+
+	//log.Println("dopo:  " + newURL.String() + fragment)
+
+	returnURLstring := element + quote + `/go?u=` + marshalURL(&newURL) + fragment + quote
+	return returnURLstring
+
+}
+
+func replaceURLcss(urlString string, element string, currentURLp *url.URL) string {
+
+	//pulisco contorni
+	newurlString := strings.Replace(urlString, `url(`, ``, -1)
+	newurlString = strings.Replace(newurlString, `)`, ``, -1)
+	newurlString = strings.Replace(newurlString, `'`, ``, -1)
+	newurlString = strings.Replace(newurlString, `"`, ``, -1)
+	newurlString = strings.Replace(newurlString, ` `, ``, -1) //nuovo, non sono sicuro
+
+	//la parso
+	urlp, err := url.Parse(newurlString)
+	if err != nil {
+		log.Println("ignoro url che non ho potuto parsare:")
+		log.Println(err)
+		return urlString
+	}
+
+	//la faccio diventare assoluta
+	newURL := sanitizeURL(urlp, currentURLp)
+
+	//elimino il fragment prima del marshall e lo aggiungo alla fine
+	fragment := ""
+	if newURL.Fragment != "" {
+		fragment = "#" + newURL.Fragment
+		newURL.Fragment = ""
+	}
+
+	returnURLstring := `url('/go?u=` + marshalURL(&newURL) + fragment + `')`
+	return returnURLstring
+}
+
+func transformPage(b string, originalURL *url.URL) string {
+
+	//occupiamoci ora di tutti gli href
+	replaceURLelem := func(urlString string) string {
+		return replaceURLhtml(urlString, "href=", originalURL)
+	}
+	re := regexp.MustCompile(`href=("|')(.*?)("|')`)
+	transformed := re.ReplaceAllStringFunc(b, replaceURLelem)
+
+	//occupiamoci ora di tutti gli src
+	replaceURLelem = func(urlString string) string {
+		return replaceURLhtml(urlString, "src=", originalURL)
+	}
+	re = regexp.MustCompile(`src=("|')(.*?)("|')`)
+	transformed = re.ReplaceAllStringFunc(transformed, replaceURLelem)
+
+	//occupiamoci delle url css
+	//url
+	replaceURLelem = func(urlString string) string {
+		return replaceURLcss(urlString, "url(", originalURL)
+	}
+	re = regexp.MustCompile(`url\((.*?)\)`)
+	transformed = re.ReplaceAllStringFunc(transformed, replaceURLelem)
+	//import diretti
+	replaceURLelem = func(urlString string) string {
+		return replaceURLhtml(urlString, "import ", originalURL)
+	}
+	re = regexp.MustCompile(`import ("|')(.*?)("|')`)
+	transformed = re.ReplaceAllStringFunc(transformed, replaceURLelem)
+
+	return transformed
+
+}
+
+func gopage(w http.ResponseWriter, r *http.Request) {
+
+	//log.Println("fetch url gopage: " + r.URL.String())
+	//fmt.Println("GET params were:", r.URL.Query())
+
+	// mi accerto di avere i dati sulla pagina da raccogliere
+	urlParam, urlexists := r.URL.Query()["u"]
+	if urlexists == false || len(urlParam) != 1 || urlParam[0] == "" {
+		io.WriteString(w, "errore url")
+		return
+	}
+	pageurl := unmarshalURL(urlParam[0])
+	log.Println("fetch url gopage unmarshalled: " + pageurl.String())
+	// vado a pescare la pagina richiesta
+	response, err := http.Get(pageurl.String())
+	if err != nil {
+		io.WriteString(w, "errore on getting page encoded in param u")
+		return
+	}
+	defer response.Body.Close()
+	body, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		io.WriteString(w, "errore read body")
+		return
+	}
+
+	mimetype := response.Header.Get("Content-Type")
+	w.Header().Set("Content-Type", mimetype)
+	//log.Println(pageurl.String() + " " + mimetype)
+
+	//ora riscrivo il contenuto se e' css o html
+	if strings.Contains(mimetype, `text/css`) || strings.Contains(mimetype, `text/html`) {
+		respString := transformPage(string(body), pageurl)
+		io.WriteString(w, respString)
+	} else {
+		// per i mimetype che non mi interessano
+		// c'e' da trovare un modo per scaricarli e fornirli mentre sono in download...
+		io.WriteString(w, string(body))
+	}
+
+}
+
+func mainpage(w http.ResponseWriter, r *http.Request) {
+
+	respString := `
+	<!DOCTYPE html> 
+	<html>
+	<body>
+	<form action="">
+	tell us where to go:
+	<input type="text" name="u" value="ping.wit.com">
+	<input type="submit" value="Submit">
+	</form>
+	</br>
+ 	`
+
+	log.Println("no go page, must fetch url " + r.URL.String())
+	//fmt.Println("GET params were:", r.URL.Query())
+	urlParam, urlexists := r.URL.Query()["u"]
+	if urlexists && len(urlParam) == 1 && urlParam[0] != "" {
+		urlp, err := url.Parse(string(urlParam[0]))
+		if err != nil {
+			log.Fatal(err)
+		}
+		urlp.Scheme = "http"
+		marshalledURL := marshalURL(urlp)
+		respString += `<iframe style="width: 100%; height: 550px " src="/go?u=` +
+			marshalledURL + `"><p>Your browser does not support iframes</p></iframe></body></html>`
+	} else {
+		respString += "</body></html>"
+	}
+	io.WriteString(w, respString)
+}
+
+func main() {
+	http.HandleFunc("/go", gopage)
+	http.HandleFunc("/", mainpage)
+	http.ListenAndServe(":8000", nil)
+}