| 1 |
package auth_test |
| 2 |
|
| 3 |
import ( |
| 4 |
"encoding/base64" |
| 5 |
"io" |
| 6 |
"io/ioutil" |
| 7 |
"net" |
| 8 |
"net/http" |
| 9 |
"net/http/httptest" |
| 10 |
"net/url" |
| 11 |
"os" |
| 12 |
"os/exec" |
| 13 |
"os/signal" |
| 14 |
"sync/atomic" |
| 15 |
"testing" |
| 16 |
|
| 17 |
"github.com/elazarl/goproxy" |
| 18 |
"github.com/elazarl/goproxy/ext/auth" |
| 19 |
) |
| 20 |
|
| 21 |
type ConstantHanlder string |
| 22 |
|
| 23 |
func (h ConstantHanlder) ServeHTTP(w http.ResponseWriter, r *http.Request) { |
| 24 |
io.WriteString(w, string(h)) |
| 25 |
} |
| 26 |
|
| 27 |
func oneShotProxy(proxy *goproxy.ProxyHttpServer) (client *http.Client, s *httptest.Server) { |
| 28 |
s = httptest.NewServer(proxy) |
| 29 |
|
| 30 |
proxyUrl, _ := url.Parse(s.URL) |
| 31 |
tr := &http.Transport{Proxy: http.ProxyURL(proxyUrl)} |
| 32 |
client = &http.Client{Transport: tr} |
| 33 |
return |
| 34 |
} |
| 35 |
|
| 36 |
func times(n int, s string) string { |
| 37 |
r := make([]byte, 0, n*len(s)) |
| 38 |
for i := 0; i < n; i++ { |
| 39 |
r = append(r, s...) |
| 40 |
} |
| 41 |
return string(r) |
| 42 |
} |
| 43 |
|
| 44 |
func TestBasicConnectAuthWithCurl(t *testing.T) { |
| 45 |
expected := ":c>" |
| 46 |
background := httptest.NewTLSServer(ConstantHanlder(expected)) |
| 47 |
defer background.Close() |
| 48 |
proxy := goproxy.NewProxyHttpServer() |
| 49 |
proxy.OnRequest().HandleConnect(auth.BasicConnect("my_realm", func(user, passwd string) bool { |
| 50 |
return user == "user" && passwd == "open sesame" |
| 51 |
})) |
| 52 |
_, proxyserver := oneShotProxy(proxy) |
| 53 |
defer proxyserver.Close() |
| 54 |
|
| 55 |
cmd := exec.Command("curl", |
| 56 |
"--silent", "--show-error", "--insecure", |
| 57 |
"-x", proxyserver.URL, |
| 58 |
"-U", "user:open sesame", |
| 59 |
"-p", |
| 60 |
"--url", background.URL+"/[1-3]", |
| 61 |
) |
| 62 |
out, err := cmd.CombinedOutput() // if curl got error, it'll show up in stderr |
| 63 |
if err != nil { |
| 64 |
t.Fatal(err, string(out)) |
| 65 |
} |
| 66 |
finalexpected := times(3, expected) |
| 67 |
if string(out) != finalexpected { |
| 68 |
t.Error("Expected", finalexpected, "got", string(out)) |
| 69 |
} |
| 70 |
} |
| 71 |
|
| 72 |
func TestBasicAuthWithCurl(t *testing.T) { |
| 73 |
expected := ":c>" |
| 74 |
background := httptest.NewServer(ConstantHanlder(expected)) |
| 75 |
defer background.Close() |
| 76 |
proxy := goproxy.NewProxyHttpServer() |
| 77 |
proxy.OnRequest().Do(auth.Basic("my_realm", func(user, passwd string) bool { |
| 78 |
return user == "user" && passwd == "open sesame" |
| 79 |
})) |
| 80 |
_, proxyserver := oneShotProxy(proxy) |
| 81 |
defer proxyserver.Close() |
| 82 |
|
| 83 |
cmd := exec.Command("curl", |
| 84 |
"--silent", "--show-error", |
| 85 |
"-x", proxyserver.URL, |
| 86 |
"-U", "user:open sesame", |
| 87 |
"--url", background.URL+"/[1-3]", |
| 88 |
) |
| 89 |
out, err := cmd.CombinedOutput() // if curl got error, it'll show up in stderr |
| 90 |
if err != nil { |
| 91 |
t.Fatal(err, string(out)) |
| 92 |
} |
| 93 |
finalexpected := times(3, expected) |
| 94 |
if string(out) != finalexpected { |
| 95 |
t.Error("Expected", finalexpected, "got", string(out)) |
| 96 |
} |
| 97 |
} |
| 98 |
|
| 99 |
func TestBasicAuth(t *testing.T) { |
| 100 |
expected := "hello" |
| 101 |
background := httptest.NewServer(ConstantHanlder(expected)) |
| 102 |
defer background.Close() |
| 103 |
proxy := goproxy.NewProxyHttpServer() |
| 104 |
proxy.OnRequest().Do(auth.Basic("my_realm", func(user, passwd string) bool { |
| 105 |
return user == "user" && passwd == "open sesame" |
| 106 |
})) |
| 107 |
client, proxyserver := oneShotProxy(proxy) |
| 108 |
defer proxyserver.Close() |
| 109 |
|
| 110 |
// without auth |
| 111 |
resp, err := client.Get(background.URL) |
| 112 |
if err != nil { |
| 113 |
t.Fatal(err) |
| 114 |
} |
| 115 |
if resp.Header.Get("Proxy-Authenticate") != "Basic realm=my_realm" { |
| 116 |
t.Error("Expected Proxy-Authenticate header got", resp.Header.Get("Proxy-Authenticate")) |
| 117 |
} |
| 118 |
if resp.StatusCode != 407 { |
| 119 |
t.Error("Expected status 407 Proxy Authentication Required, got", resp.Status) |
| 120 |
} |
| 121 |
|
| 122 |
// with auth |
| 123 |
req, err := http.NewRequest("GET", background.URL, nil) |
| 124 |
if err != nil { |
| 125 |
t.Fatal(err) |
| 126 |
} |
| 127 |
req.Header.Set("Proxy-Authorization", |
| 128 |
"Basic "+base64.StdEncoding.EncodeToString([]byte("user:open sesame"))) |
| 129 |
resp, err = client.Do(req) |
| 130 |
if err != nil { |
| 131 |
t.Fatal(err) |
| 132 |
} |
| 133 |
if resp.StatusCode != 200 { |
| 134 |
t.Error("Expected status 200 OK, got", resp.Status) |
| 135 |
} |
| 136 |
msg, err := ioutil.ReadAll(resp.Body) |
| 137 |
if err != nil { |
| 138 |
t.Fatal(err) |
| 139 |
} |
| 140 |
if string(msg) != "hello" { |
| 141 |
t.Errorf("Expected '%s', actual '%s'", expected, string(msg)) |
| 142 |
} |
| 143 |
} |
| 144 |
|
| 145 |
func TestWithBrowser(t *testing.T) { |
| 146 |
// an easy way to check if auth works with webserver |
| 147 |
// to test, run with |
| 148 |
// $ go test -run TestWithBrowser -- server |
| 149 |
// configure a browser to use the printed proxy address, use the proxy |
| 150 |
// and exit with Ctrl-C. It will throw error if your haven't actually used the proxy |
| 151 |
if os.Args[len(os.Args)-1] != "server" { |
| 152 |
return |
| 153 |
} |
| 154 |
proxy := goproxy.NewProxyHttpServer() |
| 155 |
println("proxy localhost port 8082") |
| 156 |
access := int32(0) |
| 157 |
proxy.OnRequest().Do(auth.Basic("my_realm", func(user, passwd string) bool { |
| 158 |
atomic.AddInt32(&access, 1) |
| 159 |
return user == "user" && passwd == "1234" |
| 160 |
})) |
| 161 |
l, err := net.Listen("tcp", "localhost:8082") |
| 162 |
if err != nil { |
| 163 |
t.Fatal(err) |
| 164 |
} |
| 165 |
ch := make(chan os.Signal) |
| 166 |
signal.Notify(ch, os.Interrupt) |
| 167 |
go func() { |
| 168 |
<-ch |
| 169 |
l.Close() |
| 170 |
}() |
| 171 |
http.Serve(l, proxy) |
| 172 |
if access <= 0 { |
| 173 |
t.Error("No one accessed the proxy") |
| 174 |
} |
| 175 |
} |