go-gost/gost
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add tls config option

Browse Source
This commit is contained in:
ginuerzh
2022-01-05 00:02:55 +08:00
parent c428b37a36
commit 3b48c4acfb
43 changed files with 395 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
pkg/listener/dns/listener.go
View File

@ -21,23 +21,23 @@ func init() {
}
type dnsListener struct {
saddr string
addr net.Addr
server Server
cqueue chan net.Conn
errChan chan error
logger logger.Logger
md metadata
options listener.Options
}
func NewListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &dnsListener{
saddr: options.Addr,
logger: options.Logger,
logger: options.Logger,
options: options,
}
}
@ -46,7 +46,7 @@ func (l *dnsListener) Init(md md.Metadata) (err error) {
return
}
l.addr, err = net.ResolveTCPAddr("tcp", l.saddr)
l.addr, err = net.ResolveTCPAddr("tcp", l.options.Addr)
if err != nil {
return err
}
@ -55,7 +55,7 @@ func (l *dnsListener) Init(md md.Metadata) (err error) {
case "tcp":
l.server = &dns.Server{
Net: "tcp",
Addr: l.saddr,
Addr: l.options.Addr,
Handler: l,
ReadTimeout: l.md.readTimeout,
WriteTimeout: l.md.writeTimeout,
@ -63,16 +63,16 @@ func (l *dnsListener) Init(md md.Metadata) (err error) {
case "tls":
l.server = &dns.Server{
Net: "tcp-tls",
Addr: l.saddr,
Addr: l.options.Addr,
Handler: l,
TLSConfig: l.md.tlsConfig,
TLSConfig: l.options.TLSConfig,
ReadTimeout: l.md.readTimeout,
WriteTimeout: l.md.writeTimeout,
}
case "https":
l.server = &dohServer{
addr: l.saddr,
tlsConfig: l.md.tlsConfig,
addr: l.options.Addr,
tlsConfig: l.options.TLSConfig,
server: &http.Server{
Handler: l,
ReadTimeout: l.md.readTimeout,
@ -80,10 +80,10 @@ func (l *dnsListener) Init(md md.Metadata) (err error) {
},
}
default:
l.addr, err = net.ResolveUDPAddr("udp", l.saddr)
l.addr, err = net.ResolveUDPAddr("udp", l.options.Addr)
l.server = &dns.Server{
Net: "udp",
Addr: l.saddr,
Addr: l.options.Addr,
Handler: l,
UDPSize: l.md.readBufferSize,
ReadTimeout: l.md.readTimeout,

15
pkg/listener/dns/metadata.go
View File

@ -1,10 +1,8 @@
package dns
import (
"crypto/tls"
"time"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
mdata "github.com/go-gost/gost/pkg/metadata"
)
@ -17,7 +15,6 @@ type metadata struct {
readBufferSize int
readTimeout time.Duration
writeTimeout time.Duration
tlsConfig *tls.Config
backlog int
}
@ -26,24 +23,12 @@ func (l *dnsListener) parseMetadata(md mdata.Metadata) (err error) {
mode = "mode"
readBufferSize = "readBufferSize"
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
backlog = "backlog"
)
l.md.mode = mdata.GetString(md, mode)
l.md.readBufferSize = mdata.GetInt(md, readBufferSize)
l.md.tlsConfig, err = tls_util.LoadServerConfig(
mdata.GetString(md, certFile),
mdata.GetString(md, keyFile),
mdata.GetString(md, caFile),
)
if err != nil {
return
}
l.md.backlog = mdata.GetInt(md, backlog)
if l.md.backlog <= 0 {
l.md.backlog = defaultBacklog

28
pkg/listener/http2/h2/listener.go
View File

@ -22,35 +22,35 @@ func init() {
type h2Listener struct {
server *http.Server
saddr string
addr net.Addr
cqueue chan net.Conn
errChan chan error
logger logger.Logger
md metadata
h2c bool
options listener.Options
}
func NewListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &h2Listener{
saddr: options.Addr,
logger: options.Logger,
h2c: true,
h2c: true,
logger: options.Logger,
options: options,
}
}
func NewTLSListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &h2Listener{
saddr: options.Addr,
logger: options.Logger,
logger: options.Logger,
options: options,
}
}
@ -60,10 +60,10 @@ func (l *h2Listener) Init(md md.Metadata) (err error) {
}
l.server = &http.Server{
Addr: l.saddr,
Addr: l.options.Addr,
}
ln, err := net.Listen("tcp", l.saddr)
ln, err := net.Listen("tcp", l.options.Addr)
if err != nil {
return err
}
@ -74,12 +74,12 @@ func (l *h2Listener) Init(md md.Metadata) (err error) {
http.HandlerFunc(l.handleFunc), &http2.Server{})
} else {
l.server.Handler = http.HandlerFunc(l.handleFunc)
l.server.TLSConfig = l.md.tlsConfig
l.server.TLSConfig = l.options.TLSConfig
if err := http2.ConfigureServer(l.server, nil); err != nil {
ln.Close()
return err
}
ln = tls.NewListener(ln, l.md.tlsConfig)
ln = tls.NewListener(ln, l.options.TLSConfig)
}
l.cqueue = make(chan net.Conn, l.md.backlog)

24
pkg/listener/http2/h2/metadata.go
View File

@ -1,9 +1,6 @@
package h2
import (
"crypto/tls"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
mdata "github.com/go-gost/gost/pkg/metadata"
)
@ -12,29 +9,16 @@ const (
)
type metadata struct {
path string
tlsConfig *tls.Config
backlog int
path string
backlog int
}
func (l *h2Listener) parseMetadata(md mdata.Metadata) (err error) {
const (
path = "path"
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
backlog = "backlog"
path = "path"
backlog = "backlog"
)
l.md.tlsConfig, err = tls_util.LoadServerConfig(
mdata.GetString(md, certFile),
mdata.GetString(md, keyFile),
mdata.GetString(md, caFile),
)
if err != nil {
return
}
l.md.backlog = mdata.GetInt(md, backlog)
if l.md.backlog <= 0 {
l.md.backlog = defaultBacklog

18
pkg/listener/http2/listener.go
View File

@ -20,22 +20,22 @@ func init() {
type http2Listener struct {
server *http.Server
saddr string
addr net.Addr
cqueue chan net.Conn
errChan chan error
logger logger.Logger
md metadata
options listener.Options
}
func NewListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &http2Listener{
saddr: options.Addr,
logger: options.Logger,
logger: options.Logger,
options: options,
}
}
@ -45,15 +45,15 @@ func (l *http2Listener) Init(md md.Metadata) (err error) {
}
l.server = &http.Server{
Addr: l.saddr,
Addr: l.options.Addr,
Handler: http.HandlerFunc(l.handleFunc),
TLSConfig: l.md.tlsConfig,
TLSConfig: l.options.TLSConfig,
}
if err := http2.ConfigureServer(l.server, nil); err != nil {
return err
}
ln, err := net.Listen("tcp", l.saddr)
ln, err := net.Listen("tcp", l.options.Addr)
if err != nil {
return err
}
@ -63,7 +63,7 @@ func (l *http2Listener) Init(md md.Metadata) (err error) {
&util.TCPKeepAliveListener{
TCPListener: ln.(*net.TCPListener),
},
l.md.tlsConfig,
l.options.TLSConfig,
)
l.cqueue = make(chan net.Conn, l.md.backlog)

15
pkg/listener/http2/metadata.go
View File

@ -1,11 +1,9 @@
package http2
import (
"crypto/tls"
"net/http"
"time"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
mdata "github.com/go-gost/gost/pkg/metadata"
)
@ -15,7 +13,6 @@ const (
type metadata struct {
path string
tlsConfig *tls.Config
handshakeTimeout time.Duration
readHeaderTimeout time.Duration
readBufferSize int
@ -28,9 +25,6 @@ type metadata struct {
func (l *http2Listener) parseMetadata(md mdata.Metadata) (err error) {
const (
path = "path"
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
handshakeTimeout = "handshakeTimeout"
readHeaderTimeout = "readHeaderTimeout"
readBufferSize = "readBufferSize"
@ -38,15 +32,6 @@ func (l *http2Listener) parseMetadata(md mdata.Metadata) (err error) {
backlog = "backlog"
)
l.md.tlsConfig, err = tls_util.LoadServerConfig(
mdata.GetString(md, certFile),
mdata.GetString(md, keyFile),
mdata.GetString(md, caFile),
)
if err != nil {
return
}
l.md.backlog = mdata.GetInt(md, backlog)
if l.md.backlog <= 0 {
l.md.backlog = defaultBacklog

14
pkg/listener/option.go
View File

@ -1,15 +1,17 @@
package listener
import (
"crypto/tls"
"net/url"
"github.com/go-gost/gost/pkg/logger"
)
type Options struct {
Addr string
Auths []*url.Userinfo
Logger logger.Logger
Addr string
Auths []*url.Userinfo
TLSConfig *tls.Config
Logger logger.Logger
}
type Option func(opts *Options)
@ -26,6 +28,12 @@ func AuthsOption(auths ...*url.Userinfo) Option {
}
}
func TLSConfigOption(tlsConfig *tls.Config) Option {
return func(opts *Options) {
opts.TLSConfig = tlsConfig
}
}
func LoggerOption(logger logger.Logger) Option {
return func(opts *Options) {
opts.Logger = logger

14
pkg/listener/quic/listener.go
View File

@ -17,22 +17,22 @@ func init() {
}
type quicListener struct {
addr string
ln quic.Listener
cqueue chan net.Conn
errChan chan error
logger logger.Logger
md metadata
options listener.Options
}
func NewListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &quicListener{
addr: options.Addr,
logger: options.Logger,
logger: options.Logger,
options: options,
}
}
@ -41,7 +41,7 @@ func (l *quicListener) Init(md md.Metadata) (err error) {
return
}
laddr, err := net.ResolveUDPAddr("udp", l.addr)
laddr, err := net.ResolveUDPAddr("udp", l.options.Addr)
if err != nil {
return
}
@ -67,7 +67,7 @@ func (l *quicListener) Init(md md.Metadata) (err error) {
},
}
tlsCfg := l.md.tlsConfig
tlsCfg := l.options.TLSConfig
tlsCfg.NextProtos = []string{"http/3", "quic/v1"}
ln, err := quic.Listen(conn, tlsCfg, config)

16
pkg/listener/quic/metadata.go
View File

@ -1,10 +1,8 @@
package quic
import (
"crypto/tls"
"time"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
mdata "github.com/go-gost/gost/pkg/metadata"
)
@ -17,7 +15,6 @@ type metadata struct {
handshakeTimeout time.Duration
maxIdleTimeout time.Duration
tlsConfig *tls.Config
cipherKey []byte
backlog int
}
@ -28,23 +25,10 @@ func (l *quicListener) parseMetadata(md mdata.Metadata) (err error) {
handshakeTimeout = "handshakeTimeout"
maxIdleTimeout = "maxIdleTimeout"
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
backlog = "backlog"
cipherKey = "cipherKey"
)
l.md.tlsConfig, err = tls_util.LoadServerConfig(
mdata.GetString(md, certFile),
mdata.GetString(md, keyFile),
mdata.GetString(md, caFile),
)
if err != nil {
return
}
l.md.backlog = mdata.GetInt(md, backlog)
if l.md.backlog <= 0 {
l.md.backlog = defaultBacklog

18
pkg/listener/tls/listener.go
View File

@ -15,20 +15,20 @@ func init() {
}
type tlsListener struct {
addr string
net.Listener
logger logger.Logger
md metadata
logger logger.Logger
md metadata
options listener.Options
}
func NewListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &tlsListener{
addr: options.Addr,
logger: options.Logger,
logger: options.Logger,
options: options,
}
}
@ -37,12 +37,12 @@ func (l *tlsListener) Init(md md.Metadata) (err error) {
return
}
ln, err := net.Listen("tcp", l.addr)
ln, err := net.Listen("tcp", l.options.Addr)
if err != nil {
return
}
l.Listener = tls.NewListener(ln, l.md.tlsConfig)
l.Listener = tls.NewListener(ln, l.options.TLSConfig)
return
}

19
pkg/listener/tls/metadata.go
View File

@ -1,31 +1,12 @@
package tls
import (
"crypto/tls"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
mdata "github.com/go-gost/gost/pkg/metadata"
)
type metadata struct {
tlsConfig *tls.Config
}
func (l *tlsListener) parseMetadata(md mdata.Metadata) (err error) {
const (
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
)
l.md.tlsConfig, err = tls_util.LoadServerConfig(
mdata.GetString(md, certFile),
mdata.GetString(md, keyFile),
mdata.GetString(md, caFile),
)
if err != nil {
return
}
return
}

14
pkg/listener/tls/mux/listener.go
View File

@ -16,22 +16,22 @@ func init() {
}
type mtlsListener struct {
addr string
net.Listener
cqueue chan net.Conn
errChan chan error
logger logger.Logger
md metadata
options listener.Options
}
func NewListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &mtlsListener{
addr: options.Addr,
logger: options.Logger,
logger: options.Logger,
options: options,
}
}
@ -40,11 +40,11 @@ func (l *mtlsListener) Init(md md.Metadata) (err error) {
return
}
ln, err := net.Listen("tcp", l.addr)
ln, err := net.Listen("tcp", l.options.Addr)
if err != nil {
return
}
l.Listener = tls.NewListener(ln, l.md.tlsConfig)
l.Listener = tls.NewListener(ln, l.options.TLSConfig)
l.cqueue = make(chan net.Conn, l.md.backlog)
l.errChan = make(chan error, 1)

17
pkg/listener/tls/mux/metadata.go
View File

@ -1,10 +1,8 @@
package mux
import (
"crypto/tls"
"time"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
mdata "github.com/go-gost/gost/pkg/metadata"
)
@ -13,8 +11,6 @@ const (
)
type metadata struct {
tlsConfig *tls.Config
muxKeepAliveDisabled bool
muxKeepAliveInterval time.Duration
muxKeepAliveTimeout time.Duration
@ -27,10 +23,6 @@ type metadata struct {
func (l *mtlsListener) parseMetadata(md mdata.Metadata) (err error) {
const (
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
backlog = "backlog"
muxKeepAliveDisabled = "muxKeepAliveDisabled"
@ -41,15 +33,6 @@ func (l *mtlsListener) parseMetadata(md mdata.Metadata) (err error) {
muxMaxStreamBuffer = "muxMaxStreamBuffer"
)
l.md.tlsConfig, err = tls_util.LoadServerConfig(
mdata.GetString(md, certFile),
mdata.GetString(md, keyFile),
mdata.GetString(md, caFile),
)
if err != nil {
return
}
l.md.backlog = mdata.GetInt(md, backlog)
if l.md.backlog <= 0 {
l.md.backlog = defaultBacklog

24
pkg/listener/ws/listener.go
View File

@ -20,7 +20,6 @@ func init() {
}
type wsListener struct {
saddr string
addr net.Addr
upgrader *websocket.Upgrader
srv *http.Server
@ -29,28 +28,29 @@ type wsListener struct {
errChan chan error
logger logger.Logger
md metadata
options listener.Options
}
func NewListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &wsListener{
saddr: options.Addr,
logger: options.Logger,
logger: options.Logger,
options: options,
}
}
func NewTLSListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &wsListener{
saddr: options.Addr,
logger: options.Logger,
tlsEnabled: true,
logger: options.Logger,
options: options,
}
}
@ -70,7 +70,7 @@ func (l *wsListener) Init(md md.Metadata) (err error) {
mux := http.NewServeMux()
mux.Handle(l.md.path, http.HandlerFunc(l.upgrade))
l.srv = &http.Server{
Addr: l.saddr,
Addr: l.options.Addr,
Handler: mux,
ReadHeaderTimeout: l.md.readHeaderTimeout,
}
@ -78,12 +78,12 @@ func (l *wsListener) Init(md md.Metadata) (err error) {
l.cqueue = make(chan net.Conn, l.md.backlog)
l.errChan = make(chan error, 1)
ln, err := net.Listen("tcp", l.saddr)
ln, err := net.Listen("tcp", l.options.Addr)
if err != nil {
return
}
if l.tlsEnabled {
ln = tls.NewListener(ln, l.md.tlsConfig)
ln = tls.NewListener(ln, l.options.TLSConfig)
}
l.addr = ln.Addr()

20
pkg/listener/ws/metadata.go
View File

@ -1,11 +1,9 @@
package ws
import (
"crypto/tls"
"net/http"
"time"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
mdata "github.com/go-gost/gost/pkg/metadata"
)
@ -15,9 +13,8 @@ const (
)
type metadata struct {
path string
backlog int
tlsConfig *tls.Config
path string
backlog int
handshakeTimeout time.Duration
readHeaderTimeout time.Duration
@ -30,10 +27,6 @@ type metadata struct {
func (l *wsListener) parseMetadata(md mdata.Metadata) (err error) {
const (
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
path = "path"
backlog = "backlog"
@ -46,15 +39,6 @@ func (l *wsListener) parseMetadata(md mdata.Metadata) (err error) {
header = "header"
)
l.md.tlsConfig, err = tls_util.LoadServerConfig(
mdata.GetString(md, certFile),
mdata.GetString(md, keyFile),
mdata.GetString(md, caFile),
)
if err != nil {
return
}
l.md.path = mdata.GetString(md, path)
if l.md.path == "" {
l.md.path = defaultPath

26
pkg/listener/ws/mux/listener.go
View File

@ -21,37 +21,37 @@ func init() {
}
type mwsListener struct {
saddr string
addr net.Addr
upgrader *websocket.Upgrader
srv *http.Server
cqueue chan net.Conn
errChan chan error
tlsEnabled bool
logger logger.Logger
md metadata
tlsEnabled bool
options listener.Options
}
func NewListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &mwsListener{
saddr: options.Addr,
logger: options.Logger,
logger: options.Logger,
options: options,
}
}
func NewTLSListener(opts ...listener.Option) listener.Listener {
options := &listener.Options{}
options := listener.Options{}
for _, opt := range opts {
opt(options)
opt(&options)
}
return &mwsListener{
saddr: options.Addr,
logger: options.Logger,
tlsEnabled: true,
logger: options.Logger,
options: options,
}
}
@ -75,7 +75,7 @@ func (l *mwsListener) Init(md md.Metadata) (err error) {
mux := http.NewServeMux()
mux.Handle(path, http.HandlerFunc(l.upgrade))
l.srv = &http.Server{
Addr: l.saddr,
Addr: l.options.Addr,
Handler: mux,
ReadHeaderTimeout: l.md.readHeaderTimeout,
}
@ -83,12 +83,12 @@ func (l *mwsListener) Init(md md.Metadata) (err error) {
l.cqueue = make(chan net.Conn, l.md.backlog)
l.errChan = make(chan error, 1)
ln, err := net.Listen("tcp", l.saddr)
ln, err := net.Listen("tcp", l.options.Addr)
if err != nil {
return
}
if l.tlsEnabled {
ln = tls.NewListener(ln, l.md.tlsConfig)
ln = tls.NewListener(ln, l.options.TLSConfig)
}
l.addr = ln.Addr()

22
pkg/listener/ws/mux/metadata.go
View File

@ -1,11 +1,9 @@
package mux
import (
"crypto/tls"
"net/http"
"time"
tls_util "github.com/go-gost/gost/pkg/common/util/tls"
mdata "github.com/go-gost/gost/pkg/metadata"
)
@ -15,10 +13,9 @@ const (
)
type metadata struct {
path string
backlog int
tlsConfig *tls.Config
header http.Header
path string
backlog int
header http.Header
handshakeTimeout time.Duration
readHeaderTimeout time.Duration
@ -40,10 +37,6 @@ func (l *mwsListener) parseMetadata(md mdata.Metadata) (err error) {
backlog = "backlog"
header = "header"
certFile = "certFile"
keyFile = "keyFile"
caFile = "caFile"
handshakeTimeout = "handshakeTimeout"
readHeaderTimeout = "readHeaderTimeout"
readBufferSize = "readBufferSize"
@ -58,15 +51,6 @@ func (l *mwsListener) parseMetadata(md mdata.Metadata) (err error) {
muxMaxStreamBuffer = "muxMaxStreamBuffer"
)
l.md.tlsConfig, err = tls_util.LoadServerConfig(
mdata.GetString(md, certFile),
mdata.GetString(md, keyFile),
mdata.GetString(md, caFile),
)
if err != nil {
return
}
l.md.path = mdata.GetString(md, path)
if l.md.path == "" {
l.md.path = defaultPath