|
|
@@ -1,303 +1,105 @@
|
|
|
-/* SPDX-License-Identifier: MIT
|
|
|
- *
|
|
|
- * Copyright (C) 2017-2022 WireGuard LLC. All Rights Reserved.
|
|
|
- */
|
|
|
-
|
|
|
package wireguard
|
|
|
|
|
|
import (
|
|
|
"context"
|
|
|
+ "errors"
|
|
|
"fmt"
|
|
|
"net"
|
|
|
"net/netip"
|
|
|
- "os"
|
|
|
-
|
|
|
- "github.com/sagernet/wireguard-go/tun"
|
|
|
- "github.com/xtls/xray-core/features/dns"
|
|
|
- "gvisor.dev/gvisor/pkg/buffer"
|
|
|
- "gvisor.dev/gvisor/pkg/tcpip"
|
|
|
- "gvisor.dev/gvisor/pkg/tcpip/adapters/gonet"
|
|
|
- "gvisor.dev/gvisor/pkg/tcpip/header"
|
|
|
- "gvisor.dev/gvisor/pkg/tcpip/link/channel"
|
|
|
- "gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
|
|
|
- "gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
|
|
|
- "gvisor.dev/gvisor/pkg/tcpip/stack"
|
|
|
- "gvisor.dev/gvisor/pkg/tcpip/transport/tcp"
|
|
|
- "gvisor.dev/gvisor/pkg/tcpip/transport/udp"
|
|
|
-)
|
|
|
-
|
|
|
-type netTun struct {
|
|
|
- ep *channel.Endpoint
|
|
|
- stack *stack.Stack
|
|
|
- events chan tun.Event
|
|
|
- incomingPacket chan *buffer.View
|
|
|
- mtu int
|
|
|
- dnsClient dns.Client
|
|
|
- hasV4, hasV6 bool
|
|
|
-}
|
|
|
+ "runtime"
|
|
|
+ "strconv"
|
|
|
+ "strings"
|
|
|
+ "sync"
|
|
|
|
|
|
-type Net netTun
|
|
|
-
|
|
|
-func CreateNetTUN(localAddresses []netip.Addr, dnsClient dns.Client, mtu int) (tun.Device, *Net, error) {
|
|
|
- opts := stack.Options{
|
|
|
- NetworkProtocols: []stack.NetworkProtocolFactory{ipv4.NewProtocol, ipv6.NewProtocol},
|
|
|
- TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol, udp.NewProtocol},
|
|
|
- HandleLocal: true,
|
|
|
- }
|
|
|
- dev := &netTun{
|
|
|
- ep: channel.New(1024, uint32(mtu), ""),
|
|
|
- stack: stack.New(opts),
|
|
|
- events: make(chan tun.Event, 10),
|
|
|
- incomingPacket: make(chan *buffer.View),
|
|
|
- dnsClient: dnsClient,
|
|
|
- mtu: mtu,
|
|
|
- }
|
|
|
- dev.ep.AddNotify(dev)
|
|
|
- tcpipErr := dev.stack.CreateNIC(1, dev.ep)
|
|
|
- if tcpipErr != nil {
|
|
|
- return nil, nil, fmt.Errorf("CreateNIC: %v", tcpipErr)
|
|
|
- }
|
|
|
- for _, ip := range localAddresses {
|
|
|
- var protoNumber tcpip.NetworkProtocolNumber
|
|
|
- if ip.Is4() {
|
|
|
- protoNumber = ipv4.ProtocolNumber
|
|
|
- } else if ip.Is6() {
|
|
|
- protoNumber = ipv6.ProtocolNumber
|
|
|
- }
|
|
|
- protoAddr := tcpip.ProtocolAddress{
|
|
|
- Protocol: protoNumber,
|
|
|
- AddressWithPrefix: tcpip.AddrFromSlice(ip.AsSlice()).WithPrefix(),
|
|
|
- }
|
|
|
- tcpipErr := dev.stack.AddProtocolAddress(1, protoAddr, stack.AddressProperties{})
|
|
|
- if tcpipErr != nil {
|
|
|
- return nil, nil, fmt.Errorf("AddProtocolAddress(%v): %v", ip, tcpipErr)
|
|
|
- }
|
|
|
- if ip.Is4() {
|
|
|
- dev.hasV4 = true
|
|
|
- } else if ip.Is6() {
|
|
|
- dev.hasV6 = true
|
|
|
- }
|
|
|
- }
|
|
|
- if dev.hasV4 {
|
|
|
- dev.stack.AddRoute(tcpip.Route{Destination: header.IPv4EmptySubnet, NIC: 1})
|
|
|
- }
|
|
|
- if dev.hasV6 {
|
|
|
- dev.stack.AddRoute(tcpip.Route{Destination: header.IPv6EmptySubnet, NIC: 1})
|
|
|
- }
|
|
|
+ "github.com/xtls/xray-core/common/log"
|
|
|
|
|
|
- dev.events <- tun.EventUp
|
|
|
- return dev, (*Net)(dev), nil
|
|
|
-}
|
|
|
+ "golang.zx2c4.com/wireguard/conn"
|
|
|
+ "golang.zx2c4.com/wireguard/device"
|
|
|
+ "golang.zx2c4.com/wireguard/tun"
|
|
|
+)
|
|
|
|
|
|
-func (tun *netTun) Name() (string, error) {
|
|
|
- return "go", nil
|
|
|
+type Tunnel interface {
|
|
|
+ BuildDevice(ipc string, bind conn.Bind) error
|
|
|
+ DialContextTCPAddrPort(ctx context.Context, addr netip.AddrPort) (net.Conn, error)
|
|
|
+ DialUDPAddrPort(laddr, raddr netip.AddrPort) (net.Conn, error)
|
|
|
+ Close() error
|
|
|
}
|
|
|
|
|
|
-func (tun *netTun) File() *os.File {
|
|
|
- return nil
|
|
|
+type tunnel struct {
|
|
|
+ tun tun.Device
|
|
|
+ device *device.Device
|
|
|
+ rw sync.Mutex
|
|
|
}
|
|
|
|
|
|
-func (tun *netTun) Events() chan tun.Event {
|
|
|
- return tun.events
|
|
|
-}
|
|
|
+func (t *tunnel) BuildDevice(ipc string, bind conn.Bind) (err error) {
|
|
|
+ t.rw.Lock()
|
|
|
+ defer t.rw.Unlock()
|
|
|
|
|
|
-func (tun *netTun) Read(buf []byte, offset int) (int, error) {
|
|
|
- view, ok := <-tun.incomingPacket
|
|
|
- if !ok {
|
|
|
- return 0, os.ErrClosed
|
|
|
+ if t.device != nil {
|
|
|
+ return errors.New("device is already initialized")
|
|
|
}
|
|
|
|
|
|
- return view.Read(buf[offset:])
|
|
|
-}
|
|
|
-
|
|
|
-func (tun *netTun) Write(buf []byte, offset int) (int, error) {
|
|
|
- packet := buf[offset:]
|
|
|
- if len(packet) == 0 {
|
|
|
- return 0, nil
|
|
|
+ logger := &device.Logger{
|
|
|
+ Verbosef: func(format string, args ...any) {
|
|
|
+ log.Record(&log.GeneralMessage{
|
|
|
+ Severity: log.Severity_Debug,
|
|
|
+ Content: fmt.Sprintf(format, args...),
|
|
|
+ })
|
|
|
+ },
|
|
|
+ Errorf: func(format string, args ...any) {
|
|
|
+ log.Record(&log.GeneralMessage{
|
|
|
+ Severity: log.Severity_Error,
|
|
|
+ Content: fmt.Sprintf(format, args...),
|
|
|
+ })
|
|
|
+ },
|
|
|
}
|
|
|
|
|
|
- pkb := stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: buffer.MakeWithData(packet)})
|
|
|
- switch packet[0] >> 4 {
|
|
|
- case 4:
|
|
|
- tun.ep.InjectInbound(header.IPv4ProtocolNumber, pkb)
|
|
|
- case 6:
|
|
|
- tun.ep.InjectInbound(header.IPv6ProtocolNumber, pkb)
|
|
|
+ t.device = device.NewDevice(t.tun, bind, logger)
|
|
|
+ if err = t.device.IpcSet(ipc); err != nil {
|
|
|
+ return err
|
|
|
}
|
|
|
-
|
|
|
- return len(buf), nil
|
|
|
-}
|
|
|
-
|
|
|
-func (tun *netTun) WriteNotify() {
|
|
|
- pkt := tun.ep.Read()
|
|
|
- if pkt == nil {
|
|
|
- return
|
|
|
+ if err = t.device.Up(); err != nil {
|
|
|
+ return err
|
|
|
}
|
|
|
-
|
|
|
- view := pkt.ToView()
|
|
|
- pkt.DecRef()
|
|
|
-
|
|
|
- tun.incomingPacket <- view
|
|
|
-}
|
|
|
-
|
|
|
-func (tun *netTun) Flush() error {
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
-func (tun *netTun) Close() error {
|
|
|
- tun.stack.RemoveNIC(1)
|
|
|
+func (t *tunnel) Close() (err error) {
|
|
|
+ t.rw.Lock()
|
|
|
+ defer t.rw.Unlock()
|
|
|
|
|
|
- if tun.events != nil {
|
|
|
- close(tun.events)
|
|
|
- }
|
|
|
-
|
|
|
- tun.ep.Close()
|
|
|
-
|
|
|
- if tun.incomingPacket != nil {
|
|
|
- close(tun.incomingPacket)
|
|
|
+ if t.device == nil {
|
|
|
+ return nil
|
|
|
}
|
|
|
|
|
|
+ t.device.Close()
|
|
|
+ t.device = nil
|
|
|
+ err = t.tun.Close()
|
|
|
+ t.tun = nil
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
-func (tun *netTun) MTU() (int, error) {
|
|
|
- return tun.mtu, nil
|
|
|
-}
|
|
|
-
|
|
|
-func convertToFullAddr(endpoint netip.AddrPort) (tcpip.FullAddress, tcpip.NetworkProtocolNumber) {
|
|
|
- var protoNumber tcpip.NetworkProtocolNumber
|
|
|
- if endpoint.Addr().Is4() {
|
|
|
- protoNumber = ipv4.ProtocolNumber
|
|
|
+func CalculateInterfaceName(name string) (tunName string) {
|
|
|
+ if runtime.GOOS == "darwin" {
|
|
|
+ tunName = "utun"
|
|
|
+ } else if name != "" {
|
|
|
+ tunName = name
|
|
|
} else {
|
|
|
- protoNumber = ipv6.ProtocolNumber
|
|
|
- }
|
|
|
- return tcpip.FullAddress{
|
|
|
- NIC: 1,
|
|
|
- Addr: tcpip.AddrFromSlice(endpoint.Addr().AsSlice()),
|
|
|
- Port: endpoint.Port(),
|
|
|
- }, protoNumber
|
|
|
-}
|
|
|
-
|
|
|
-func (net *Net) DialContextTCPAddrPort(ctx context.Context, addr netip.AddrPort) (*gonet.TCPConn, error) {
|
|
|
- fa, pn := convertToFullAddr(addr)
|
|
|
- return gonet.DialContextTCP(ctx, net.stack, fa, pn)
|
|
|
-}
|
|
|
-
|
|
|
-func (net *Net) DialContextTCP(ctx context.Context, addr *net.TCPAddr) (*gonet.TCPConn, error) {
|
|
|
- if addr == nil {
|
|
|
- return net.DialContextTCPAddrPort(ctx, netip.AddrPort{})
|
|
|
- }
|
|
|
- ip, _ := netip.AddrFromSlice(addr.IP)
|
|
|
- return net.DialContextTCPAddrPort(ctx, netip.AddrPortFrom(ip, uint16(addr.Port)))
|
|
|
-}
|
|
|
-
|
|
|
-func (net *Net) DialTCPAddrPort(addr netip.AddrPort) (*gonet.TCPConn, error) {
|
|
|
- fa, pn := convertToFullAddr(addr)
|
|
|
- return gonet.DialTCP(net.stack, fa, pn)
|
|
|
-}
|
|
|
-
|
|
|
-func (net *Net) DialTCP(addr *net.TCPAddr) (*gonet.TCPConn, error) {
|
|
|
- if addr == nil {
|
|
|
- return net.DialTCPAddrPort(netip.AddrPort{})
|
|
|
- }
|
|
|
- ip, _ := netip.AddrFromSlice(addr.IP)
|
|
|
- return net.DialTCPAddrPort(netip.AddrPortFrom(ip, uint16(addr.Port)))
|
|
|
-}
|
|
|
-
|
|
|
-func (net *Net) ListenTCPAddrPort(addr netip.AddrPort) (*gonet.TCPListener, error) {
|
|
|
- fa, pn := convertToFullAddr(addr)
|
|
|
- return gonet.ListenTCP(net.stack, fa, pn)
|
|
|
-}
|
|
|
-
|
|
|
-func (net *Net) ListenTCP(addr *net.TCPAddr) (*gonet.TCPListener, error) {
|
|
|
- if addr == nil {
|
|
|
- return net.ListenTCPAddrPort(netip.AddrPort{})
|
|
|
- }
|
|
|
- ip, _ := netip.AddrFromSlice(addr.IP)
|
|
|
- return net.ListenTCPAddrPort(netip.AddrPortFrom(ip, uint16(addr.Port)))
|
|
|
-}
|
|
|
-
|
|
|
-func (net *Net) DialUDPAddrPort(laddr, raddr netip.AddrPort) (*gonet.UDPConn, error) {
|
|
|
- var lfa, rfa *tcpip.FullAddress
|
|
|
- var pn tcpip.NetworkProtocolNumber
|
|
|
- if laddr.IsValid() || laddr.Port() > 0 {
|
|
|
- var addr tcpip.FullAddress
|
|
|
- addr, pn = convertToFullAddr(laddr)
|
|
|
- lfa = &addr
|
|
|
- }
|
|
|
- if raddr.IsValid() || raddr.Port() > 0 {
|
|
|
- var addr tcpip.FullAddress
|
|
|
- addr, pn = convertToFullAddr(raddr)
|
|
|
- rfa = &addr
|
|
|
+ tunName = "tun"
|
|
|
}
|
|
|
- return gonet.DialUDP(net.stack, lfa, rfa, pn)
|
|
|
-}
|
|
|
-
|
|
|
-func (net *Net) ListenUDPAddrPort(laddr netip.AddrPort) (*gonet.UDPConn, error) {
|
|
|
- return net.DialUDPAddrPort(laddr, netip.AddrPort{})
|
|
|
-}
|
|
|
-
|
|
|
-func (net *Net) DialUDP(laddr, raddr *net.UDPAddr) (*gonet.UDPConn, error) {
|
|
|
- var la, ra netip.AddrPort
|
|
|
- if laddr != nil {
|
|
|
- ip, _ := netip.AddrFromSlice(laddr.IP)
|
|
|
- la = netip.AddrPortFrom(ip, uint16(laddr.Port))
|
|
|
- }
|
|
|
- if raddr != nil {
|
|
|
- ip, _ := netip.AddrFromSlice(raddr.IP)
|
|
|
- ra = netip.AddrPortFrom(ip, uint16(raddr.Port))
|
|
|
- }
|
|
|
- return net.DialUDPAddrPort(la, ra)
|
|
|
-}
|
|
|
-
|
|
|
-func (net *Net) ListenUDP(laddr *net.UDPAddr) (*gonet.UDPConn, error) {
|
|
|
- return net.DialUDP(laddr, nil)
|
|
|
-}
|
|
|
-
|
|
|
-func (n *Net) HasV4() bool {
|
|
|
- return n.hasV4
|
|
|
-}
|
|
|
-
|
|
|
-func (n *Net) HasV6() bool {
|
|
|
- return n.hasV6
|
|
|
-}
|
|
|
-
|
|
|
-func IsDomainName(s string) bool {
|
|
|
- l := len(s)
|
|
|
- if l == 0 || l > 254 || l == 254 && s[l-1] != '.' {
|
|
|
- return false
|
|
|
+ interfaces, err := net.Interfaces()
|
|
|
+ if err != nil {
|
|
|
+ return
|
|
|
}
|
|
|
- last := byte('.')
|
|
|
- nonNumeric := false
|
|
|
- partlen := 0
|
|
|
- for i := 0; i < len(s); i++ {
|
|
|
- c := s[i]
|
|
|
- switch {
|
|
|
- default:
|
|
|
- return false
|
|
|
- case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '_':
|
|
|
- nonNumeric = true
|
|
|
- partlen++
|
|
|
- case '0' <= c && c <= '9':
|
|
|
- partlen++
|
|
|
- case c == '-':
|
|
|
- if last == '.' {
|
|
|
- return false
|
|
|
- }
|
|
|
- partlen++
|
|
|
- nonNumeric = true
|
|
|
- case c == '.':
|
|
|
- if last == '.' || last == '-' {
|
|
|
- return false
|
|
|
+ var tunIndex int
|
|
|
+ for _, netInterface := range interfaces {
|
|
|
+ if strings.HasPrefix(netInterface.Name, tunName) {
|
|
|
+ index, parseErr := strconv.ParseInt(netInterface.Name[len(tunName):], 10, 16)
|
|
|
+ if parseErr == nil {
|
|
|
+ tunIndex = int(index) + 1
|
|
|
}
|
|
|
- if partlen > 63 || partlen == 0 {
|
|
|
- return false
|
|
|
- }
|
|
|
- partlen = 0
|
|
|
}
|
|
|
- last = c
|
|
|
- }
|
|
|
- if last == '-' || partlen > 63 {
|
|
|
- return false
|
|
|
}
|
|
|
- return nonNumeric
|
|
|
+ tunName = fmt.Sprintf("%s%d", tunName, tunIndex)
|
|
|
+ return
|
|
|
}
|
yuhan6665