Gitingest

Include files under: 50kb

Summary

Repository: saljam/proxy
Files analyzed: 5

Estimated tokens: 1.8k

Download

Directory Structure

Directory structure:

└── saljam-proxy/

    ├── README

    ├── logger/

    │   └── logger.go

    ├── proxy/

    │   └── proxy.go

    ├── rickroll/

    │   └── rickroll.go

    └── upsidedown/

        └── upsidedown.go

Files Content

================================================
FILE: README
================================================
proxy - A simple transperent web proxy written in go.

This was written after my neighbours have taken it a bit too far using
my wireless and I wanted to have a bit of fun.  It was inspired by
upside-down-ternet[1].  :-)

src/proxy is the main proxy library.  This repository also includes
multiple simple proxies written using it:

	upsidedown flips every image requested through it.

	logger simply logs every request.

	rickroll takes a path to an flv file, and replaces every flv
	request with its contents.  i.e. it turns every youtube video
	into a rickroll.

they all listen on port 3128.

Look at src/logger or src/upsidedown for examples on how to write a
custom proxy.

To forward all web traffic to the machine running the proxy (in my case on
192.168.1.11:3128), I use the following iptables commands on the router:

iptables -t nat -A PREROUTING -s '!' 192.168.1.11 -p tcp --dport 80 -j DNAT --to 192.168.1.11:3128
iptables -t nat -A POSTROUTING -s 192.168.1.0/255.255.255.0 -d 192.168.1.11 -j MASQUERADE
iptables -A FORWARD -s 192.168.1.0/255.255.255.0 -d 192.168.1.11 -p tcp --dport 3128 -j ACCEPT

Exercises for the reader: inject js into all html pages.

[1] http://www.ex-parrot.com/pete/upside-down-ternet.html



================================================
FILE: logger/logger.go
================================================
package main

import (
	"net/http"
	"log"
	"bitbucket.org/saljam/proxy/proxy"
)

func logRequest(r *http.Request) *http.Request {
	log.Println(r.Method, r.URL, r.UserAgent(), r.Header)
	return r
}

func main() {
	p := &proxy.Proxy{
		proxy.ReqManglers{logRequest},
		proxy.ResManglers{},
	}
	err := http.ListenAndServe(":3128", p)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}




================================================
FILE: proxy/proxy.go
================================================
/*
Proxy is a simple transperent web proxy written in go.

Basic usage:

	p := &proxy.Proxy{
		proxy.ReqManglers{logRequest},
		proxy.ResManglers{flipImageRes},
	}
	log.Fatal(http.ListenAndServe(":3128", p))

Where the members of the manglers are functions which implement the signatures:

	func(*http.Request) *http.Request
	func(*http.Response) *http.Response

*/
package proxy

import (
	"net/http"
	"log"
	"io"
)

// ReqManglers are a slice of fucntions which modify requests.
// These functions must have the signature:
//	func(*http.Request) *http.Request
type ReqManglers []func(*http.Request) *http.Request

// ResManglers are a slice of fucntions which modify responses.
// These functions must have the signature:
//	func(*http.Response) *http.Response
type ResManglers []func(*http.Response) *http.Response

// Proxy implements http.Handler.
type Proxy struct{
	RequestManglers  ReqManglers
	ResponseManglers ResManglers
}

func copyHeader(from, to http.Header) {
	for hdr, items := range from {
		for _, item := range items {
			to.Add(hdr, item)
		}
	}
}

// ServeHTTP proxies the request given and writes the response to w.
func (p *Proxy) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	for _, f := range p.RequestManglers {
		req = f(req)
	}

	res, err := http.DefaultTransport.RoundTrip(req)
	if err != nil {
		log.Println("proxy fail:", err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	for _, f := range p.ResponseManglers {
		res = f(res)
	}

	copyHeader(res.Header, w.Header())

	w.WriteHeader(res.StatusCode)

	if res.Body != nil {
		io.Copy(w, res.Body)
	}
}




================================================
FILE: rickroll/rickroll.go
================================================
package main

import (
	"os"
	"net/http"
	"log"
	"flag"
	"bitbucket.org/saljam/proxy/proxy"
)

func rickRoll(res *http.Response) *http.Response {
	if ct, ok := res.Header["Content-Type"]; !ok || len(ct) == 0{
		return res
	}

	if res.Header["Content-Type"][0] == "video/x-flv" {
		res.Header.Del("Content-Length")
		if file, err := os.Open(*filename); err == nil {
			res.Body = file
			log.Println("win!")
		} else {
			log.Println("failed to open file!")
		}
	}
	return res
}

var filename = flag.String("filename", "", "Path to the replacement .flv file.")

func main() {
	flag.Parse()
	
	p := &proxy.Proxy{
		proxy.ReqManglers{},
		proxy.ResManglers{rickRoll},
	}

	err := http.ListenAndServe(":3128", p)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}



================================================
FILE: upsidedown/upsidedown.go
================================================
package main

import (
	"net/http"
	"log"
	"bitbucket.org/saljam/proxy/proxy"
	"bytes"
	"image"
	"image/jpeg"
	"image/gif"
	"image/png"
)

type imgBuffer struct{
	*bytes.Buffer
}

func (b imgBuffer) Close() error {
	return nil
}

func flipImage(m image.Image) *image.RGBA {
	b := m.Bounds()
	s := image.Point{b.Dx(), b.Dy()}
	n := image.NewRGBA(b)
	for i :=0; i < s.X; i++ {
		for j :=0; j < s.Y; j++ {
			n.Set(i, j, m.At(i, s.Y-j-1))
		}
	}
	return n
}

func flipImageRes(res *http.Response) *http.Response {
	switch res.Header["Content-Type"][0] {
	case "image/jpeg":
		m, err := jpeg.Decode(res.Body)
		if err != nil {
			log.Println("image error:", err)
			return res
		}
		buf := imgBuffer{bytes.NewBuffer([]byte{})}
		n := flipImage(m)
		jpeg.Encode(buf, n, nil)
		res.Header.Del("Content-Length")
		res.Body = buf
	case "image/gif":
		m, err := gif.Decode(res.Body)
		if err != nil {
			log.Println("image error:", err)
			return res
		}
		buf := imgBuffer{bytes.NewBuffer([]byte{})}
		n := flipImage(m)
		png.Encode(buf, n)
		res.Header.Del("Content-Length")
		res.Header.Del("Content-Type")
		res.Header.Add("Content-Type", "image/png")
		res.Body = buf
	case "image/png":
		m, err := png.Decode(res.Body)
		if err != nil {
			log.Println("image error:", err)
			return res
		}
		buf := imgBuffer{bytes.NewBuffer([]byte{})}
		n := flipImage(m)
		png.Encode(buf, n)
		res.Header.Del("Content-Length")
		res.Header.Del("Content-Type")
		res.Header.Add("Content-Type", "image/png")
		res.Body = buf
	}
	return res
}

func logRequest(r *http.Request) *http.Request {
	log.Println(r.Method, r.URL, r.UserAgent(), r.Header)
	return r
}

func main() {
	p := &proxy.Proxy{
		proxy.ReqManglers{logRequest},
		proxy.ResManglers{flipImageRes},
	}
	err := http.ListenAndServe(":3128", p)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}