mirror of
https://github.com/xvzc/SpoofDPI.git
synced 2024-12-22 14:26:31 +00:00
121 lines
2.8 KiB
Go
121 lines
2.8 KiB
Go
package util
|
|
|
|
import (
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"strconv"
|
|
"unsafe"
|
|
)
|
|
|
|
type Args struct {
|
|
Addr string
|
|
Port uint16
|
|
DnsAddr string
|
|
DnsPort uint16
|
|
EnableDoh bool
|
|
Debug bool
|
|
Banner bool
|
|
SystemProxy bool
|
|
Timeout uint16
|
|
AllowedPattern StringArray
|
|
WindowSize uint16
|
|
Version bool
|
|
}
|
|
|
|
type StringArray []string
|
|
|
|
func (arr *StringArray) String() string {
|
|
return fmt.Sprintf("%s", *arr)
|
|
}
|
|
|
|
func (arr *StringArray) Set(value string) error {
|
|
*arr = append(*arr, value)
|
|
return nil
|
|
}
|
|
|
|
func ParseArgs() *Args {
|
|
args := new(Args)
|
|
|
|
flag.StringVar(&args.Addr, "addr", "127.0.0.1", "listen address")
|
|
uintNVar(&args.Port, "port", 8080, "port")
|
|
flag.StringVar(&args.DnsAddr, "dns-addr", "8.8.8.8", "dns address")
|
|
uintNVar(&args.DnsPort, "dns-port", 53, "port number for dns")
|
|
flag.BoolVar(&args.EnableDoh, "enable-doh", false, "enable 'dns-over-https'")
|
|
flag.BoolVar(&args.Debug, "debug", false, "enable debug output")
|
|
flag.BoolVar(&args.Banner, "banner", true, "enable banner")
|
|
flag.BoolVar(&args.SystemProxy, "system-proxy", true, "enable system-wide proxy")
|
|
uintNVar(&args.Timeout, "timeout", 0, "timeout in milliseconds; no timeout when not given")
|
|
uintNVar(&args.WindowSize, "window-size", 0, `chunk size, in number of bytes, for fragmented client hello,
|
|
try lower values if the default value doesn't bypass the DPI;
|
|
when not given, the client hello packet will be sent in two parts:
|
|
fragmentation for the first data packet and the rest
|
|
`)
|
|
flag.BoolVar(&args.Version, "v", false, "print spoofdpi's version; this may contain some other relevant information")
|
|
flag.Var(
|
|
&args.AllowedPattern,
|
|
"pattern",
|
|
"bypass DPI only on packets matching this regex pattern; can be given multiple times",
|
|
)
|
|
|
|
flag.Parse()
|
|
|
|
return args
|
|
}
|
|
|
|
var (
|
|
errParse = errors.New("parse error")
|
|
errRange = errors.New("value out of range")
|
|
)
|
|
|
|
type unsigned interface {
|
|
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
|
|
}
|
|
|
|
func uintNVar[T unsigned](p *T, name string, value T, usage string) {
|
|
flag.CommandLine.Var(newUintNValue(value, p), name, usage)
|
|
}
|
|
|
|
type uintNValue[T unsigned] struct {
|
|
val *T
|
|
}
|
|
|
|
func newUintNValue[T unsigned](val T, p *T) *uintNValue[T] {
|
|
*p = val
|
|
return &uintNValue[T]{val: p}
|
|
}
|
|
|
|
func (u *uintNValue[T]) Set(s string) error {
|
|
size := int(unsafe.Sizeof(*u.val) * 8)
|
|
v, err := strconv.ParseUint(s, 0, size)
|
|
if err != nil {
|
|
err = numError(err)
|
|
}
|
|
*u.val = T(v)
|
|
return err
|
|
}
|
|
|
|
func (u *uintNValue[T]) Get() any {
|
|
if u.val == nil {
|
|
return T(0)
|
|
}
|
|
return *u.val
|
|
}
|
|
|
|
func (u *uintNValue[T]) String() string {
|
|
if u.val == nil {
|
|
return "0"
|
|
}
|
|
return strconv.FormatUint(uint64(*u.val), 10)
|
|
}
|
|
|
|
func numError(err error) error {
|
|
if errors.Is(err, strconv.ErrSyntax) {
|
|
return errParse
|
|
}
|
|
if errors.Is(err, strconv.ErrRange) {
|
|
return errRange
|
|
}
|
|
return err
|
|
}
|