From 6260b4fe2b14495357d96485f20d8cba0dea0eb4 Mon Sep 17 00:00:00 2001 From: idk Date: Tue, 25 Dec 2018 00:57:30 -0500 Subject: [PATCH] initial commit --- .gitignore | 2 + Dockerfile | 0 Makefile | 9 +++ README.md | 3 +- main.go | 159 +++++++++++++++++++++++++++++++++++++++ resolve/eepresolver.go | 63 ++++++++++++++++ socks/manager.go | 65 ++++++++++++++++ socks/manager_options.go | 1 + socks/manager_test.go | 1 + 9 files changed, 302 insertions(+), 1 deletion(-) create mode 100644 .gitignore create mode 100644 Dockerfile create mode 100644 Makefile create mode 100644 main.go create mode 100644 resolve/eepresolver.go create mode 100644 socks/manager.go create mode 100644 socks/manager_options.go create mode 100644 socks/manager_test.go diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..33d5456 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +README.md.asc +eeProxy diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..e69de29 diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..bd0d925 --- /dev/null +++ b/Makefile @@ -0,0 +1,9 @@ + +build: + go build + +fmt: + find . -name '*.go' -exec gofmt -w {} \; + +clean: + go clean diff --git a/README.md b/README.md index 30bdf56..d37a337 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,3 @@ # eeProxy -Yet another standalone, contextual-identity aware proxy for i2p. This time better organized and smaller. +Yet another standalone, contextual-identity aware proxy for i2p. This time +better organized and smaller. diff --git a/main.go b/main.go new file mode 100644 index 0000000..bc9cae2 --- /dev/null +++ b/main.go @@ -0,0 +1,159 @@ +package main + +import ( + "flag" + //"log" + "github.com/eyedeekay/eeproxy/socks" + "os" + "os/signal" + "strings" +) + +import ( + "github.com/eyedeekay/sam-forwarder/config" + "github.com/eyedeekay/samcatd-web" +) + +type flagOpts []string + +func (f *flagOpts) String() string { + r := "" + for _, s := range *f { + r += s + "," + } + return strings.TrimSuffix(r, ",") +} + +func (f *flagOpts) Set(s string) error { + *f = append(*f, s) + return nil +} + +func (f *flagOpts) StringSlice() []string { + var r []string + for _, s := range *f { + r = append(r, s) + } + return r +} + +var ( + startUp = flag.Bool("s", false, + "Start a tunnel with the passed parameters(Otherwise, they will be treated as default values.)") + encryptKeyFiles = flag.String("cr", "", + "Encrypt/decrypt the key files with a passfile") + inAllowZeroHop = flag.Bool("zi", false, + "Allow zero-hop, non-anonymous tunnels in(true or false)") + outAllowZeroHop = flag.Bool("zo", false, + "Allow zero-hop, non-anonymous tunnels out(true o false)") + useCompression = flag.Bool("z", false, + "Uze gzip(true or false)") + targetHost = flag.String("h", "127.0.0.1", + "Target host(Host of service to forward to i2p)") + targetPort = flag.String("p", "8081", + "Target port(Port of service to forward to i2p)") + reduceIdle = flag.Bool("r", false, + "Reduce tunnel quantity when idle(true or false)") + closeIdle = flag.Bool("x", false, + "Close tunnel idle(true or false)") + targetDir = flag.String("d", "./tunnels/", + "Directory to save tunnel configuration file in.") + targetDest = flag.String("de", "", + "Destination to connect client's to by default.") + iniFile = flag.String("f", "none", + "Use an ini file for configuration(config file options override passed arguments for now.)") + samHost = flag.String("sh", "127.0.0.1", + "SAM host") + samPort = flag.String("sp", "7656", + "SAM port") + tunName = flag.String("n", "socks", + "Tunnel name, this must be unique but can be anything.") + inLength = flag.Int("il", 3, + "Set inbound tunnel length(0 to 7)") + outLength = flag.Int("ol", 3, + "Set outbound tunnel length(0 to 7)") + inQuantity = flag.Int("iq", 2, + "Set inbound tunnel quantity(0 to 15)") + outQuantity = flag.Int("oq", 2, + "Set outbound tunnel quantity(0 to 15)") + inVariance = flag.Int("iv", 0, + "Set inbound tunnel length variance(-7 to 7)") + outVariance = flag.Int("ov", 0, + "Set outbound tunnel length variance(-7 to 7)") + inBackupQuantity = flag.Int("ib", 1, + "Set inbound tunnel backup quantity(0 to 5)") + outBackupQuantity = flag.Int("ob", 1, + "Set outbound tunnel backup quantity(0 to 5)") + reduceIdleTime = flag.Int("rt", 600000, + "Reduce tunnel quantity after X (milliseconds)") + closeIdleTime = flag.Int("ct", 600000, + "Reduce tunnel quantity after X (milliseconds)") + reduceIdleQuantity = flag.Int("rq", 1, + "Reduce idle tunnel quantity to X (0 to 5)") + readKeys = flag.String("conv", "", "Display the base32 and base64 values of a specified .i2pkeys file") +) + +var ( + webinterface *samcatweb.SAMWebConfig + webinterfaceerr error + err error + accessList flagOpts + config *i2ptunconf.Conf +) + +func main() { + flag.Var(&accessList, "accesslist", "Specify an access list member(can be used multiple times)") + flag.Parse() + + if *readKeys != "" { + + } + + config = i2ptunconf.NewI2PBlankTunConf() + if *iniFile != "none" && *iniFile != "" { + config, err = i2ptunconf.NewI2PTunConf(*iniFile) + } else { + *startUp = true + } + config.TargetHost = config.GetHost(*targetHost, "127.0.0.1") + config.TargetPort = config.GetPort(*targetPort, "8081") + config.SaveFile = config.GetSaveFile(true, true) + config.SaveDirectory = config.GetDir(*targetDir, "./tunnels/") + config.SamHost = config.GetSAMHost(*samHost, "127.0.0.1") + config.SamPort = config.GetSAMPort(*samPort, "7656") + config.TunName = config.GetKeys(*tunName, "socks") + config.InLength = config.GetInLength(*inLength, 3) + config.OutLength = config.GetOutLength(*outLength, 3) + config.InVariance = config.GetInVariance(*inVariance, 0) + config.OutVariance = config.GetOutVariance(*outVariance, 0) + config.InQuantity = config.GetInQuantity(*inQuantity, 2) + config.OutQuantity = config.GetOutQuantity(*outQuantity, 2) + config.InBackupQuantity = config.GetInBackups(*inBackupQuantity, 1) + config.OutBackupQuantity = config.GetOutBackups(*outBackupQuantity, 1) + config.InAllowZeroHop = config.GetInAllowZeroHop(*inAllowZeroHop, false) + config.OutAllowZeroHop = config.GetOutAllowZeroHop(*outAllowZeroHop, false) + config.UseCompression = config.GetUseCompression(*useCompression, true) + config.ReduceIdle = config.GetReduceOnIdle(*reduceIdle, true) + config.ReduceIdleTime = config.GetReduceIdleTime(*reduceIdleTime, 600000) + config.ReduceIdleQuantity = config.GetReduceIdleQuantity(*reduceIdleQuantity, 2) + config.CloseIdle = config.GetCloseOnIdle(*closeIdle, false) + config.CloseIdleTime = config.GetCloseIdleTime(*closeIdleTime, 600000) + config.KeyFilePath = config.GetKeyFile(*encryptKeyFiles, "") + config.ClientDest = config.GetClientDest(*targetDest, "", "") + + c := make(chan os.Signal, 1) + signal.Notify(c, os.Interrupt) + if tunsocks, tunerr := tunmanager.NewManager(); tunerr == nil { + go func() { + for sig := range c { + if sig == os.Interrupt { + //tunsocks.Cleanup() + } + } + }() + tunsocks.Serve() + } else { + panic(tunerr) + } + +} diff --git a/resolve/eepresolver.go b/resolve/eepresolver.go new file mode 100644 index 0000000..3f5f658 --- /dev/null +++ b/resolve/eepresolver.go @@ -0,0 +1,63 @@ +package resolver + +import ( + "context" + "fmt" + "net" + "strings" +) + +import ( + "github.com/eyedeekay/sam3" +) + +type Resolver struct { + *sam3.SAMResolver + allowedSuffixes []string +} + +func (r Resolver) Resolve(ctx context.Context, name string) (context.Context, net.Addr, error) { + return r.ResolveI2P(ctx, name) +} + +func (r Resolver) ResolveI2P(ctx context.Context, name string) (context.Context, *sam3.I2PAddr, error) { + if r.ValidateI2PAddr(name) { + return ctx, nil, fmt.Errorf("Error, not an allowed suffix") + } + raddr, err := r.SAMResolver.Resolve(name) + if err != nil { + return ctx, nil, err + } + return ctx, &raddr, nil +} + +func (r Resolver) ValidateI2PAddr(name string) bool { + noi2p := true + for _, suffix := range r.allowedSuffixes { + if strings.HasSuffix(name, suffix) { + if suffix == ".b32.i2p" { + if len(name) != 52 { + noi2p = true + break + } + } + noi2p = false + } + } + return noi2p +} + +func NewResolver() (*Resolver, error) { + return NewResolverFromOptions() +} + +func NewResolverFromOptions() (*Resolver, error) { + var r Resolver + r.allowedSuffixes = []string{".i2p", ".b32.i2p"} + var err error + r.SAMResolver, err = sam3.NewFullSAMResolver("127.0.0.1:7656") + if err != nil { + return nil, err + } + return &r, nil +} diff --git a/socks/manager.go b/socks/manager.go new file mode 100644 index 0000000..668eaf9 --- /dev/null +++ b/socks/manager.go @@ -0,0 +1,65 @@ +package tunmanager + +import ( + "context" + "fmt" + "log" + "net" +) + +import ( + "github.com/eyedeekay/eeproxy/resolve" + "github.com/eyedeekay/go-socks5" + "github.com/eyedeekay/sam3" +) + +type Manager struct { + resolver.Resolver + socks5.Config + sam3.StreamSession + conns []*sam3.SAMConn +} + +func (m Manager) Serve() error { + return nil +} + +func (m Manager) DialI2P(ctx context.Context, addr string) (*sam3.SAMConn, error) { + i2paddr, err := sam3.NewI2PAddrFromString(addr) + if err != nil { + return nil, err + } + for i, c := range m.conns { + if i2paddr.Base32() == c.RemoteAddr().(*sam3.I2PAddr).Base32() { + log.Println("Found destination for address:", i2paddr.Base32(), "at position", i) + return c, nil + } + } + newconn, err := m.StreamSession.DialI2P(i2paddr) + if err != nil { + return nil, err + } + m.conns = append(m.conns, newconn) + log.Println("Generated destination for address:", i2paddr.Base32(), "at position", len(m.conns)-1) + return m.conns[len(m.conns)-1], nil +} + +func (m Manager) Dial(ctx context.Context, network, addr string) (net.Conn, error) { + return m.DialI2P(ctx, addr) +} + +func NewManager() (*Manager, error) { + return NewManagerFromOptions() +} + +func NewManagerFromOptions() (*Manager, error) { + var m Manager + if r, err := resolver.NewResolver(); err == nil { + m.Config = socks5.Config{ + Resolver: r, + Dial: m.Dial, + } + return &m, nil + } + return nil, fmt.Errorf("Resolver creation error.") +} diff --git a/socks/manager_options.go b/socks/manager_options.go new file mode 100644 index 0000000..c6fc994 --- /dev/null +++ b/socks/manager_options.go @@ -0,0 +1 @@ +package tunmanager diff --git a/socks/manager_test.go b/socks/manager_test.go new file mode 100644 index 0000000..c6fc994 --- /dev/null +++ b/socks/manager_test.go @@ -0,0 +1 @@ +package tunmanager