sing-box/outbound/wireguard.go

234 lines
6.8 KiB
Go
Raw Normal View History

2022-08-16 23:37:51 +08:00
//go:build with_wireguard
package outbound
import (
"context"
"encoding/base64"
"encoding/hex"
"fmt"
"net"
"strings"
"github.com/sagernet/sing-box/adapter"
"github.com/sagernet/sing-box/common/dialer"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log"
"github.com/sagernet/sing-box/option"
2022-09-06 00:15:09 +08:00
"github.com/sagernet/sing-box/transport/wireguard"
2022-09-15 12:20:38 +08:00
"github.com/sagernet/sing-tun"
2022-08-16 23:37:51 +08:00
"github.com/sagernet/sing/common"
"github.com/sagernet/sing/common/debug"
E "github.com/sagernet/sing/common/exceptions"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
"github.com/sagernet/wireguard-go/device"
2022-08-16 23:37:51 +08:00
)
2022-11-06 10:36:19 +08:00
var (
_ adapter.Outbound = (*WireGuard)(nil)
_ adapter.InterfaceUpdateListener = (*WireGuard)(nil)
)
2022-08-16 23:37:51 +08:00
type WireGuard struct {
myOutboundAdapter
2022-09-06 00:15:09 +08:00
bind *wireguard.ClientBind
device *device.Device
tunDevice wireguard.Device
2022-08-16 23:37:51 +08:00
}
func NewWireGuard(ctx context.Context, router adapter.Router, logger log.ContextLogger, tag string, options option.WireGuardOutboundOptions) (*WireGuard, error) {
outbound := &WireGuard{
myOutboundAdapter: myOutboundAdapter{
protocol: C.TypeWireGuard,
network: options.Network.Build(),
router: router,
logger: logger,
tag: tag,
},
}
var reserved [3]uint8
if len(options.Reserved) > 0 {
if len(options.Reserved) != 3 {
return nil, E.New("invalid reserved value, required 3 bytes, got ", len(options.Reserved))
}
copy(reserved[:], options.Reserved)
}
var isConnect bool
var connectAddr M.Socksaddr
if len(options.Peers) < 2 {
isConnect = true
if len(options.Peers) == 1 {
connectAddr = options.Peers[0].ServerOptions.Build()
} else {
connectAddr = options.ServerOptions.Build()
}
}
2023-04-13 16:02:28 +08:00
outbound.bind = wireguard.NewClientBind(ctx, outbound, dialer.New(router, options.DialerOptions), isConnect, connectAddr, reserved)
2022-09-06 00:15:09 +08:00
localPrefixes := common.Map(options.LocalAddress, option.ListenPrefix.Build)
if len(localPrefixes) == 0 {
2022-08-16 23:37:51 +08:00
return nil, E.New("missing local address")
}
var privateKey string
2022-08-16 23:37:51 +08:00
{
bytes, err := base64.StdEncoding.DecodeString(options.PrivateKey)
if err != nil {
return nil, E.Cause(err, "decode private key")
}
privateKey = hex.EncodeToString(bytes)
}
ipcConf := "private_key=" + privateKey
if len(options.Peers) > 0 {
for i, peer := range options.Peers {
var peerPublicKey, preSharedKey string
{
bytes, err := base64.StdEncoding.DecodeString(peer.PublicKey)
if err != nil {
return nil, E.Cause(err, "decode public key for peer ", i)
}
peerPublicKey = hex.EncodeToString(bytes)
}
if peer.PreSharedKey != "" {
bytes, err := base64.StdEncoding.DecodeString(peer.PreSharedKey)
if err != nil {
return nil, E.Cause(err, "decode pre shared key for peer ", i)
}
preSharedKey = hex.EncodeToString(bytes)
}
destination := peer.ServerOptions.Build()
ipcConf += "\npublic_key=" + peerPublicKey
ipcConf += "\nendpoint=" + destination.String()
if preSharedKey != "" {
ipcConf += "\npreshared_key=" + preSharedKey
}
if len(peer.AllowedIPs) == 0 {
return nil, E.New("missing allowed_ips for peer ", i)
}
for _, allowedIP := range peer.AllowedIPs {
ipcConf += "\nallowed_ip=" + allowedIP
}
if len(peer.Reserved) > 0 {
if len(peer.Reserved) != 3 {
return nil, E.New("invalid reserved value for peer ", i, ", required 3 bytes, got ", len(peer.Reserved))
}
copy(reserved[:], options.Reserved)
outbound.bind.SetReservedForEndpoint(destination, reserved)
}
2022-08-16 23:37:51 +08:00
}
} else {
var peerPublicKey, preSharedKey string
{
bytes, err := base64.StdEncoding.DecodeString(options.PeerPublicKey)
if err != nil {
return nil, E.Cause(err, "decode peer public key")
}
peerPublicKey = hex.EncodeToString(bytes)
2022-08-16 23:37:51 +08:00
}
if options.PreSharedKey != "" {
bytes, err := base64.StdEncoding.DecodeString(options.PreSharedKey)
if err != nil {
return nil, E.Cause(err, "decode pre shared key")
}
preSharedKey = hex.EncodeToString(bytes)
}
ipcConf += "\npublic_key=" + peerPublicKey
ipcConf += "\nendpoint=" + options.ServerOptions.Build().String()
if preSharedKey != "" {
ipcConf += "\npreshared_key=" + preSharedKey
}
var has4, has6 bool
for _, address := range localPrefixes {
if address.Addr().Is4() {
has4 = true
} else {
has6 = true
}
}
if has4 {
ipcConf += "\nallowed_ip=0.0.0.0/0"
}
if has6 {
ipcConf += "\nallowed_ip=::/0"
2022-08-16 23:37:51 +08:00
}
}
mtu := options.MTU
if mtu == 0 {
2022-08-17 15:19:10 +08:00
mtu = 1408
2022-08-16 23:37:51 +08:00
}
2022-09-06 00:15:09 +08:00
var wireTunDevice wireguard.Device
var err error
2022-09-15 12:20:38 +08:00
if !options.SystemInterface && tun.WithGVisor {
2022-09-06 00:15:09 +08:00
wireTunDevice, err = wireguard.NewStackDevice(localPrefixes, mtu)
} else {
wireTunDevice, err = wireguard.NewSystemDevice(router, options.InterfaceName, localPrefixes, mtu)
}
2022-08-16 23:37:51 +08:00
if err != nil {
2022-09-06 00:15:09 +08:00
return nil, E.Cause(err, "create WireGuard device")
2022-08-16 23:37:51 +08:00
}
2022-09-06 00:15:09 +08:00
wgDevice := device.NewDevice(wireTunDevice, outbound.bind, &device.Logger{
2022-08-16 23:37:51 +08:00
Verbosef: func(format string, args ...interface{}) {
logger.Debug(fmt.Sprintf(strings.ToLower(format), args...))
},
Errorf: func(format string, args ...interface{}) {
logger.Error(fmt.Sprintf(strings.ToLower(format), args...))
},
}, options.Workers)
2022-08-16 23:37:51 +08:00
if debug.Enabled {
logger.Trace("created wireguard ipc conf: \n", ipcConf)
}
err = wgDevice.IpcSet(ipcConf)
if err != nil {
return nil, E.Cause(err, "setup wireguard")
}
outbound.device = wgDevice
2022-09-06 00:15:09 +08:00
outbound.tunDevice = wireTunDevice
2022-08-16 23:37:51 +08:00
return outbound, nil
}
2022-11-06 10:36:19 +08:00
func (w *WireGuard) InterfaceUpdated() error {
w.bind.Reset()
return nil
}
2022-08-16 23:37:51 +08:00
func (w *WireGuard) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
switch network {
case N.NetworkTCP:
w.logger.InfoContext(ctx, "outbound connection to ", destination)
case N.NetworkUDP:
w.logger.InfoContext(ctx, "outbound packet connection to ", destination)
}
if destination.IsFqdn() {
addrs, err := w.router.LookupDefault(ctx, destination.Fqdn)
if err != nil {
return nil, err
}
2022-09-06 00:15:09 +08:00
return N.DialSerial(ctx, w.tunDevice, network, destination, addrs)
2022-08-16 23:37:51 +08:00
}
2022-09-06 00:15:09 +08:00
return w.tunDevice.DialContext(ctx, network, destination)
2022-08-16 23:37:51 +08:00
}
func (w *WireGuard) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
w.logger.InfoContext(ctx, "outbound packet connection to ", destination)
2022-09-06 00:15:09 +08:00
return w.tunDevice.ListenPacket(ctx, destination)
2022-08-16 23:37:51 +08:00
}
func (w *WireGuard) NewConnection(ctx context.Context, conn net.Conn, metadata adapter.InboundContext) error {
2022-08-31 12:50:26 +08:00
return NewConnection(ctx, w, conn, metadata)
2022-08-16 23:37:51 +08:00
}
func (w *WireGuard) NewPacketConnection(ctx context.Context, conn N.PacketConn, metadata adapter.InboundContext) error {
return NewPacketConnection(ctx, w, conn, metadata)
}
func (w *WireGuard) Start() error {
2022-09-06 00:15:09 +08:00
return w.tunDevice.Start()
2022-08-16 23:37:51 +08:00
}
func (w *WireGuard) Close() error {
2022-09-23 13:14:31 +08:00
if w.device != nil {
w.device.Close()
}
2023-04-05 21:41:06 +08:00
w.tunDevice.Close()
return nil
2022-08-16 23:37:51 +08:00
}