2019-10-03 17:00:41 -05:00
|
|
|
// Copyright 2015 Matthew Holt and The Caddy Authors
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
|
|
|
package reverseproxy
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"flag"
|
2019-10-31 12:34:54 -05:00
|
|
|
"fmt"
|
2019-11-04 14:18:42 -05:00
|
|
|
"net"
|
2019-10-03 17:00:41 -05:00
|
|
|
"net/http"
|
2020-04-27 16:53:38 -05:00
|
|
|
"strconv"
|
2019-10-03 17:00:41 -05:00
|
|
|
|
|
|
|
"github.com/caddyserver/caddy/v2"
|
|
|
|
"github.com/caddyserver/caddy/v2/caddyconfig"
|
2020-04-27 16:53:38 -05:00
|
|
|
"github.com/caddyserver/caddy/v2/caddyconfig/httpcaddyfile"
|
2019-10-03 17:00:41 -05:00
|
|
|
caddycmd "github.com/caddyserver/caddy/v2/cmd"
|
|
|
|
"github.com/caddyserver/caddy/v2/modules/caddyhttp"
|
|
|
|
"github.com/caddyserver/caddy/v2/modules/caddyhttp/headers"
|
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
caddycmd.RegisterCommand(caddycmd.Command{
|
|
|
|
Name: "reverse-proxy",
|
|
|
|
Func: cmdReverseProxy,
|
2020-02-27 22:52:41 -05:00
|
|
|
Usage: "[--from <addr>] [--to <addr>] [--change-host-header]",
|
2019-10-03 17:00:41 -05:00
|
|
|
Short: "A quick and production-ready reverse proxy",
|
|
|
|
Long: `
|
|
|
|
A simple but production-ready reverse proxy. Useful for quick deployments,
|
|
|
|
demos, and development.
|
|
|
|
|
2020-04-27 16:53:38 -05:00
|
|
|
Simply shuttles HTTP(S) traffic from the --from address to the --to address.
|
2019-10-03 17:00:41 -05:00
|
|
|
|
2020-04-27 16:53:38 -05:00
|
|
|
Unless otherwise specified in the addresses, the --from address will be
|
|
|
|
assumed to be HTTPS if a hostname is given, and the --to address will be
|
|
|
|
assumed to be HTTP.
|
|
|
|
|
|
|
|
If the --from address has a host or IP, Caddy will attempt to serve the
|
|
|
|
proxy over HTTPS with a certificate (unless overridden by the HTTP scheme
|
|
|
|
or port).
|
2020-02-27 22:52:41 -05:00
|
|
|
|
|
|
|
If --change-host-header is set, the Host header on the request will be modified
|
|
|
|
from its original incoming value to the address of the upstream. (Otherwise, by
|
|
|
|
default, all incoming headers are passed through unmodified.)
|
2019-10-03 17:00:41 -05:00
|
|
|
`,
|
|
|
|
Flags: func() *flag.FlagSet {
|
2020-06-21 23:40:54 -05:00
|
|
|
fs := flag.NewFlagSet("reverse-proxy", flag.ExitOnError)
|
2020-04-27 16:53:38 -05:00
|
|
|
fs.String("from", "localhost", "Address on which to receive traffic")
|
2022-01-19 14:51:46 -05:00
|
|
|
fs.String("to", "", "Upstream address to which traffic should be sent")
|
2020-02-27 22:52:41 -05:00
|
|
|
fs.Bool("change-host-header", false, "Set upstream Host header to address of upstream")
|
2021-10-11 17:15:00 -05:00
|
|
|
fs.Bool("insecure", false, "Disable TLS verification (WARNING: DISABLES SECURITY BY NOT VERIFYING SSL CERTIFICATES!)")
|
2019-10-03 17:00:41 -05:00
|
|
|
return fs
|
|
|
|
}(),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func cmdReverseProxy(fs caddycmd.Flags) (int, error) {
|
2020-05-21 14:09:49 -05:00
|
|
|
caddy.TrapSignals()
|
|
|
|
|
2019-10-03 17:00:41 -05:00
|
|
|
from := fs.String("from")
|
|
|
|
to := fs.String("to")
|
2020-02-27 22:52:41 -05:00
|
|
|
changeHost := fs.Bool("change-host-header")
|
2020-05-12 11:43:18 -05:00
|
|
|
insecure := fs.Bool("insecure")
|
2019-10-03 17:00:41 -05:00
|
|
|
|
2020-04-27 16:53:38 -05:00
|
|
|
httpPort := strconv.Itoa(caddyhttp.DefaultHTTPPort)
|
|
|
|
httpsPort := strconv.Itoa(caddyhttp.DefaultHTTPSPort)
|
|
|
|
|
|
|
|
if to == "" {
|
|
|
|
return caddy.ExitCodeFailedStartup, fmt.Errorf("--to is required")
|
2019-10-03 17:00:41 -05:00
|
|
|
}
|
|
|
|
|
2020-04-27 16:53:38 -05:00
|
|
|
// set up the downstream address; assume missing information from given parts
|
|
|
|
fromAddr, err := httpcaddyfile.ParseAddress(from)
|
|
|
|
if err != nil {
|
|
|
|
return caddy.ExitCodeFailedStartup, fmt.Errorf("invalid downstream address %s: %v", from, err)
|
|
|
|
}
|
|
|
|
if fromAddr.Path != "" {
|
|
|
|
return caddy.ExitCodeFailedStartup, fmt.Errorf("paths are not allowed: %s", from)
|
2019-10-03 17:00:41 -05:00
|
|
|
}
|
2020-04-27 16:53:38 -05:00
|
|
|
if fromAddr.Scheme == "" {
|
|
|
|
if fromAddr.Port == httpPort || fromAddr.Host == "" {
|
|
|
|
fromAddr.Scheme = "http"
|
|
|
|
} else {
|
|
|
|
fromAddr.Scheme = "https"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if fromAddr.Port == "" {
|
|
|
|
if fromAddr.Scheme == "http" {
|
|
|
|
fromAddr.Port = httpPort
|
|
|
|
} else if fromAddr.Scheme == "https" {
|
|
|
|
fromAddr.Port = httpsPort
|
|
|
|
}
|
2019-10-31 12:34:54 -05:00
|
|
|
}
|
2019-10-03 17:00:41 -05:00
|
|
|
|
2020-04-27 16:53:38 -05:00
|
|
|
// set up the upstream address; assume missing information from given parts
|
|
|
|
toAddr, err := httpcaddyfile.ParseAddress(to)
|
2019-10-03 17:00:41 -05:00
|
|
|
if err != nil {
|
2020-04-27 16:53:38 -05:00
|
|
|
return caddy.ExitCodeFailedStartup, fmt.Errorf("invalid upstream address %s: %v", to, err)
|
2019-10-03 17:00:41 -05:00
|
|
|
}
|
2020-04-27 16:53:38 -05:00
|
|
|
if toAddr.Path != "" {
|
|
|
|
return caddy.ExitCodeFailedStartup, fmt.Errorf("paths are not allowed: %s", to)
|
2019-10-03 17:00:41 -05:00
|
|
|
}
|
2020-04-27 16:53:38 -05:00
|
|
|
if toAddr.Scheme == "" {
|
|
|
|
if toAddr.Port == httpsPort {
|
|
|
|
toAddr.Scheme = "https"
|
|
|
|
} else {
|
|
|
|
toAddr.Scheme = "http"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if toAddr.Port == "" {
|
|
|
|
if toAddr.Scheme == "http" {
|
|
|
|
toAddr.Port = httpPort
|
|
|
|
} else if toAddr.Scheme == "https" {
|
|
|
|
toAddr.Port = httpsPort
|
2019-11-04 14:18:42 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-27 16:53:38 -05:00
|
|
|
// proceed to build the handler and server
|
|
|
|
|
2019-10-03 17:00:41 -05:00
|
|
|
ht := HTTPTransport{}
|
2020-04-27 16:53:38 -05:00
|
|
|
if toAddr.Scheme == "https" {
|
2019-10-03 17:00:41 -05:00
|
|
|
ht.TLS = new(TLSConfig)
|
2020-05-12 11:43:18 -05:00
|
|
|
if insecure {
|
|
|
|
ht.TLS.InsecureSkipVerify = true
|
|
|
|
}
|
2019-10-03 17:00:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
handler := Handler{
|
|
|
|
TransportRaw: caddyconfig.JSONModuleObject(ht, "protocol", "http", nil),
|
2020-04-27 16:53:38 -05:00
|
|
|
Upstreams: UpstreamPool{{Dial: net.JoinHostPort(toAddr.Host, toAddr.Port)}},
|
2020-02-27 22:52:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
if changeHost {
|
|
|
|
handler.Headers = &headers.Handler{
|
2019-10-03 17:00:41 -05:00
|
|
|
Request: &headers.HeaderOps{
|
|
|
|
Set: http.Header{
|
2020-02-27 22:52:41 -05:00
|
|
|
"Host": []string{"{http.reverse_proxy.upstream.hostport}"},
|
2019-10-03 17:00:41 -05:00
|
|
|
},
|
|
|
|
},
|
2020-02-27 22:52:41 -05:00
|
|
|
}
|
2019-10-03 17:00:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
route := caddyhttp.Route{
|
|
|
|
HandlersRaw: []json.RawMessage{
|
|
|
|
caddyconfig.JSONModuleObject(handler, "handler", "reverse_proxy", nil),
|
|
|
|
},
|
|
|
|
}
|
2020-04-27 16:53:38 -05:00
|
|
|
if fromAddr.Host != "" {
|
2019-12-10 15:36:46 -05:00
|
|
|
route.MatcherSetsRaw = []caddy.ModuleMap{
|
2020-04-09 14:22:05 -05:00
|
|
|
{
|
2020-04-27 16:53:38 -05:00
|
|
|
"host": caddyconfig.JSON(caddyhttp.MatchHost{fromAddr.Host}, nil),
|
2019-10-03 17:00:41 -05:00
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
server := &caddyhttp.Server{
|
|
|
|
Routes: caddyhttp.RouteList{route},
|
2020-04-27 16:53:38 -05:00
|
|
|
Listen: []string{":" + fromAddr.Port},
|
2019-10-03 17:00:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
httpApp := caddyhttp.App{
|
|
|
|
Servers: map[string]*caddyhttp.Server{"proxy": server},
|
|
|
|
}
|
|
|
|
|
|
|
|
cfg := &caddy.Config{
|
2019-11-15 17:52:19 -05:00
|
|
|
Admin: &caddy.AdminConfig{Disabled: true},
|
2019-12-10 15:36:46 -05:00
|
|
|
AppsRaw: caddy.ModuleMap{
|
2019-10-03 17:00:41 -05:00
|
|
|
"http": caddyconfig.JSON(httpApp, nil),
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
err = caddy.Run(cfg)
|
|
|
|
if err != nil {
|
|
|
|
return caddy.ExitCodeFailedStartup, err
|
|
|
|
}
|
|
|
|
|
2020-04-27 16:53:38 -05:00
|
|
|
fmt.Printf("Caddy proxying %s -> %s\n", fromAddr.String(), toAddr.String())
|
2019-10-03 17:00:41 -05:00
|
|
|
|
|
|
|
select {}
|
|
|
|
}
|