Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/go-httpproxy/httpproxy
Go HTTP proxy server library
https://github.com/go-httpproxy/httpproxy
go golang http-proxy proxy proxy-server web-proxy
Last synced: 12 days ago
JSON representation
Go HTTP proxy server library
- Host: GitHub
- URL: https://github.com/go-httpproxy/httpproxy
- Owner: go-httpproxy
- License: bsd-3-clause
- Created: 2018-01-29T14:09:51.000Z (almost 7 years ago)
- Default Branch: master
- Last Pushed: 2022-06-02T13:34:46.000Z (over 2 years ago)
- Last Synced: 2024-08-01T17:29:23.729Z (3 months ago)
- Topics: go, golang, http-proxy, proxy, proxy-server, web-proxy
- Language: Go
- Homepage:
- Size: 115 KB
- Stars: 215
- Watchers: 8
- Forks: 58
- Open Issues: 10
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Go HTTP proxy server library
[](https://godoc.org/github.com/go-httpproxy/httpproxy)
Package httpproxy provides a customizable HTTP proxy; supports HTTP, HTTPS through
CONNECT. And also provides HTTPS connection using "Man in the Middle" style
attack.
It's easy to use. `httpproxy.Proxy` implements `Handler` interface of `net/http`
package to offer `http.ListenAndServe` function.
## Installing
```sh
go get -u github.com/go-httpproxy/httpproxy
# or
go get -u gopkg.in/httpproxy.v1
```
## Usage
Library has two significant structs: Proxy and Context.
### Proxy struct
```go
// Proxy defines parameters for running an HTTP Proxy. It implements
// http.Handler interface for ListenAndServe function. If you need, you must
// set Proxy struct before handling requests.
type Proxy struct {
// Session number of last proxy request.
SessionNo int64
// RoundTripper interface to obtain remote response.
// By default, it uses &http.Transport{}.
Rt http.RoundTripper
// Certificate key pair.
Ca tls.Certificate
// User data to use free.
UserData interface{}
// Error callback.
OnError func(ctx *Context, where string, err *Error, opErr error)
// Accept callback. It greets proxy request like ServeHTTP function of
// http.Handler.
// If it returns true, stops processing proxy request.
OnAccept func(ctx *Context, w http.ResponseWriter, r *http.Request) bool
// Auth callback. If you need authentication, set this callback.
// If it returns true, authentication succeeded.
OnAuth func(ctx *Context, authType string, user string, pass string) bool
// Connect callback. It sets connect action and new host.
// If len(newhost) > 0, host changes.
OnConnect func(ctx *Context, host string) (ConnectAction ConnectAction,
newHost string)
// Request callback. It greets remote request.
// If it returns non-nil response, stops processing remote request.
OnRequest func(ctx *Context, req *http.Request) (resp *http.Response)
// Response callback. It greets remote response.
// Remote response sends after this callback.
OnResponse func(ctx *Context, req *http.Request, resp *http.Response)
// If ConnectAction is ConnectMitm, it sets chunked to Transfer-Encoding.
// By default, true.
MitmChunked bool
// HTTP Authentication type. If it's not specified (""), uses "Basic".
// By default, "".
AuthType string
}
```
### Context struct
```go
// Context keeps context of each proxy request.
type Context struct {
// Pointer of Proxy struct handled this context.
// It's using internally. Don't change in Context struct!
Prx *Proxy
// Session number of this context obtained from Proxy struct.
SessionNo int64
// Sub session number of processing remote connection.
SubSessionNo int64
// Original Proxy request.
// It's using internally. Don't change in Context struct!
Req *http.Request
// Original Proxy request, if proxy request method is CONNECT.
// It's using internally. Don't change in Context struct!
ConnectReq *http.Request
// Action of after the CONNECT, if proxy request method is CONNECT.
// It's using internally. Don't change in Context struct!
ConnectAction ConnectAction
// Remote host, if proxy request method is CONNECT.
// It's using internally. Don't change in Context struct!
ConnectHost string
// User data to use free.
UserData interface{}
}
```
## Examples
For more examples, examples/
### examples/go-httpproxy-simple
```go
package main
import (
"log"
"net/http"
"github.com/go-httpproxy/httpproxy"
)
func OnError(ctx *httpproxy.Context, where string,
err *httpproxy.Error, opErr error) {
// Log errors.
log.Printf("ERR: %s: %s [%s]", where, err, opErr)
}
func OnAccept(ctx *httpproxy.Context, w http.ResponseWriter,
r *http.Request) bool {
// Handle local request has path "/info"
if r.Method == "GET" && !r.URL.IsAbs() && r.URL.Path == "/info" {
w.Write([]byte("This is go-httpproxy."))
return true
}
return false
}
func OnAuth(ctx *httpproxy.Context, authType string, user string, pass string) bool {
// Auth test user.
if user == "test" && pass == "1234" {
return true
}
return false
}
func OnConnect(ctx *httpproxy.Context, host string) (
ConnectAction httpproxy.ConnectAction, newHost string) {
// Apply "Man in the Middle" to all ssl connections. Never change host.
return httpproxy.ConnectMitm, host
}
func OnRequest(ctx *httpproxy.Context, req *http.Request) (
resp *http.Response) {
// Log proxying requests.
log.Printf("INFO: Proxy: %s %s", req.Method, req.URL.String())
return
}
func OnResponse(ctx *httpproxy.Context, req *http.Request,
resp *http.Response) {
// Add header "Via: go-httpproxy".
resp.Header.Add("Via", "go-httpproxy")
}
func main() {
// Create a new proxy with default certificate pair.
prx, _ := httpproxy.NewProxy()
// Set handlers.
prx.OnError = OnError
prx.OnAccept = OnAccept
prx.OnAuth = OnAuth
prx.OnConnect = OnConnect
prx.OnRequest = OnRequest
prx.OnResponse = OnResponse
// Listen...
http.ListenAndServe(":8080", prx)
}
```