mirror of
https://github.com/ScuroNeko/mtg.git
synced 2026-08-31 19:14:01 +03:00
Rename server to proxy
This commit is contained in:
9seconds
@@ -0,0 +1,51 @@
|
||||
package proxy
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
)
|
||||
|
||||
type Cipher interface {
|
||||
Encrypt([]byte) []byte
|
||||
Decrypt([]byte) []byte
|
||||
}
|
||||
|
||||
type CipherReadWriteCloser struct {
|
||||
crypt Cipher
|
||||
conn io.ReadWriteCloser
|
||||
rest *bytes.Buffer
|
||||
}
|
||||
|
||||
func (c *CipherReadWriteCloser) Read(p []byte) (n int, err error) {
|
||||
n, err = c.conn.Read(p)
|
||||
copy(p, c.crypt.Decrypt(p[:n]))
|
||||
return
|
||||
}
|
||||
|
||||
func (c *CipherReadWriteCloser) Write(p []byte) (n int, err error) {
|
||||
encrypted := c.crypt.Encrypt(p)
|
||||
|
||||
curN := 0
|
||||
for len(encrypted) > 0 {
|
||||
curN, err = c.conn.Write(encrypted)
|
||||
n += curN
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
encrypted = encrypted[n:]
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (c *CipherReadWriteCloser) Close() error {
|
||||
return c.conn.Close()
|
||||
}
|
||||
|
||||
func newCipherReadWriteCloser(conn io.ReadWriteCloser, crypt Cipher) *CipherReadWriteCloser {
|
||||
return &CipherReadWriteCloser{
|
||||
conn: conn,
|
||||
crypt: crypt,
|
||||
rest: &bytes.Buffer{},
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
package proxy
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
|
||||
"github.com/juju/errors"
|
||||
)
|
||||
|
||||
type CtxReadWriteCloser struct {
|
||||
ctx context.Context
|
||||
conn io.ReadWriteCloser
|
||||
cancel context.CancelFunc
|
||||
}
|
||||
|
||||
func (c *CtxReadWriteCloser) Read(p []byte) (int, error) {
|
||||
select {
|
||||
case <-c.ctx.Done():
|
||||
return 0, errors.Annotate(c.ctx.Err(), "Read is failed because of closed context")
|
||||
default:
|
||||
n, err := c.conn.Read(p)
|
||||
if err != nil {
|
||||
c.cancel()
|
||||
}
|
||||
return n, err
|
||||
}
|
||||
}
|
||||
|
||||
func (c *CtxReadWriteCloser) Write(p []byte) (int, error) {
|
||||
select {
|
||||
case <-c.ctx.Done():
|
||||
return 0, errors.Annotate(c.ctx.Err(), "Write is failed because of closed context")
|
||||
default:
|
||||
n, err := c.conn.Write(p)
|
||||
if err != nil {
|
||||
c.cancel()
|
||||
}
|
||||
return n, err
|
||||
}
|
||||
}
|
||||
|
||||
func (c *CtxReadWriteCloser) Close() error {
|
||||
return c.conn.Close()
|
||||
}
|
||||
|
||||
func newCtxReadWriteCloser(conn io.ReadWriteCloser, ctx context.Context, cancel context.CancelFunc) io.ReadWriteCloser {
|
||||
return &CtxReadWriteCloser{
|
||||
conn: conn,
|
||||
ctx: ctx,
|
||||
cancel: cancel,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package proxy
|
||||
|
||||
import (
|
||||
"io"
|
||||
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
type LogReadWriteCloser struct {
|
||||
conn io.ReadWriteCloser
|
||||
logger *zap.SugaredLogger
|
||||
sockid string
|
||||
name string
|
||||
}
|
||||
|
||||
func (l *LogReadWriteCloser) Read(p []byte) (n int, err error) {
|
||||
n, err = l.conn.Read(p)
|
||||
l.logger.Debugw("Finish reading", "name", l.name, "socketid", l.sockid, "nbytes", n, "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
func (l *LogReadWriteCloser) Write(p []byte) (n int, err error) {
|
||||
n, err = l.conn.Write(p)
|
||||
l.logger.Debugw("Finish writing", "name", l.name, "socketid", l.sockid, "nbytes", n, "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
func (l *LogReadWriteCloser) Close() error {
|
||||
err := l.conn.Close()
|
||||
l.logger.Debugw("Finish closing socket", "name", l.name, "socketid", l.sockid, "error", err)
|
||||
return err
|
||||
}
|
||||
|
||||
func newLogReadWriteCloser(conn io.ReadWriteCloser, logger *zap.SugaredLogger, sockid string, name string) io.ReadWriteCloser {
|
||||
return &LogReadWriteCloser{
|
||||
conn: conn,
|
||||
logger: logger,
|
||||
sockid: sockid,
|
||||
name: name,
|
||||
}
|
||||
}
|
||||
+159
@@ -0,0 +1,159 @@
|
||||
package proxy
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"net"
|
||||
"strconv"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/9seconds/mtg/obfuscated2"
|
||||
"github.com/juju/errors"
|
||||
uuid "github.com/satori/go.uuid"
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
const bufferSize = 4096
|
||||
|
||||
type Server struct {
|
||||
ip net.IP
|
||||
port int
|
||||
secret []byte
|
||||
logger *zap.SugaredLogger
|
||||
lsock net.Listener
|
||||
ctx context.Context
|
||||
readTimeout time.Duration
|
||||
writeTimeout time.Duration
|
||||
}
|
||||
|
||||
func (s *Server) Serve() error {
|
||||
lsock, err := net.Listen("tcp", s.Addr())
|
||||
if err != nil {
|
||||
return errors.Annotate(err, "Cannot create listen socket")
|
||||
}
|
||||
|
||||
for {
|
||||
if conn, err := lsock.Accept(); err != nil {
|
||||
s.logger.Warn("Cannot allocate incoming connection", "error", err)
|
||||
} else {
|
||||
go s.accept(conn)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Server) Addr() string {
|
||||
return net.JoinHostPort(s.ip.String(), strconv.Itoa(s.port))
|
||||
}
|
||||
|
||||
func (s *Server) accept(conn net.Conn) {
|
||||
defer conn.Close()
|
||||
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
socketID := s.makeSocketID()
|
||||
|
||||
s.logger.Debugw("Client connected",
|
||||
"secret", s.secret,
|
||||
"addr", conn.RemoteAddr().String(),
|
||||
"socketid", socketID,
|
||||
)
|
||||
|
||||
clientConn, dc, err := s.getClientStream(conn, ctx, cancel, socketID)
|
||||
if err != nil {
|
||||
s.logger.Warnw("Cannot initialize client connection",
|
||||
"secret", s.secret,
|
||||
"addr", conn.RemoteAddr().String(),
|
||||
"socketid", socketID,
|
||||
"error", err,
|
||||
)
|
||||
return
|
||||
}
|
||||
defer clientConn.Close()
|
||||
|
||||
tgConn, err := s.getTelegramStream(dc, ctx, cancel, socketID)
|
||||
if err != nil {
|
||||
s.logger.Warnw("Cannot initialize Telegram connection",
|
||||
"socketid", socketID,
|
||||
"error", err,
|
||||
)
|
||||
return
|
||||
}
|
||||
defer tgConn.Close()
|
||||
|
||||
wait := &sync.WaitGroup{}
|
||||
wait.Add(2)
|
||||
go s.pipe(wait, clientConn, tgConn)
|
||||
go s.pipe(wait, tgConn, clientConn)
|
||||
<-ctx.Done()
|
||||
wait.Wait()
|
||||
|
||||
s.logger.Debugw("Client disconnected",
|
||||
"secret", s.secret,
|
||||
"addr", conn.RemoteAddr().String(),
|
||||
"socketid", socketID,
|
||||
)
|
||||
}
|
||||
|
||||
func (s *Server) makeSocketID() string {
|
||||
return uuid.NewV4().String()
|
||||
}
|
||||
|
||||
func (s *Server) getClientStream(conn net.Conn, ctx context.Context, cancel context.CancelFunc, socketID string) (io.ReadWriteCloser, int16, error) {
|
||||
wConn := newTimeoutReadWriteCloser(conn, s.readTimeout, s.writeTimeout)
|
||||
frame, err := obfuscated2.ExtractFrame(wConn)
|
||||
if err != nil {
|
||||
return nil, 0, errors.Annotate(err, "Cannot create client stream")
|
||||
}
|
||||
|
||||
obfs2, dc, err := obfuscated2.ParseObfuscated2ClientFrame(s.secret, frame)
|
||||
if err != nil {
|
||||
return nil, 0, errors.Annotate(err, "Cannot create client stream")
|
||||
}
|
||||
|
||||
wConn = newLogReadWriteCloser(wConn, s.logger, socketID, "client")
|
||||
wConn = newCipherReadWriteCloser(conn, obfs2)
|
||||
wConn = newCtxReadWriteCloser(wConn, ctx, cancel)
|
||||
|
||||
return wConn, dc, nil
|
||||
}
|
||||
|
||||
func (s *Server) getTelegramStream(dc int16, ctx context.Context, cancel context.CancelFunc, socketID string) (io.ReadWriteCloser, error) {
|
||||
socket, err := dialToTelegram(dc, s.readTimeout)
|
||||
if err != nil {
|
||||
return nil, errors.Annotate(err, "Cannot dial")
|
||||
}
|
||||
wConn := newTimeoutReadWriteCloser(socket, s.readTimeout, s.writeTimeout)
|
||||
|
||||
obfs2, frame := obfuscated2.MakeTelegramObfuscated2Frame()
|
||||
if n, err := socket.Write(frame); err != nil || n != len(frame) {
|
||||
return nil, errors.Annotate(err, "Cannot write hadnshake frame")
|
||||
}
|
||||
|
||||
wConn = newLogReadWriteCloser(socket, s.logger, socketID, "telegram")
|
||||
wConn = newCipherReadWriteCloser(wConn, obfs2)
|
||||
wConn = newCtxReadWriteCloser(wConn, ctx, cancel)
|
||||
|
||||
return wConn, nil
|
||||
}
|
||||
|
||||
func (s *Server) pipe(wait *sync.WaitGroup, reader io.Reader, writer io.Writer) {
|
||||
defer wait.Done()
|
||||
|
||||
buf := make([]byte, bufferSize)
|
||||
io.CopyBuffer(writer, reader, buf)
|
||||
}
|
||||
|
||||
func NewServer(ip net.IP, port int, secret []byte, logger *zap.SugaredLogger,
|
||||
readTimeout, writeTimeout time.Duration) *Server {
|
||||
return &Server{
|
||||
ip: ip,
|
||||
port: port,
|
||||
secret: secret,
|
||||
ctx: context.Background(),
|
||||
logger: logger,
|
||||
readTimeout: readTimeout,
|
||||
writeTimeout: writeTimeout,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
package proxy
|
||||
|
||||
import (
|
||||
"net"
|
||||
"time"
|
||||
|
||||
"github.com/juju/errors"
|
||||
)
|
||||
|
||||
var telegramDCIPs = [5]string{
|
||||
"149.154.175.50:443",
|
||||
"149.154.167.51:443",
|
||||
"149.154.175.100:443",
|
||||
"149.154.167.91:443",
|
||||
"149.154.171.5:443",
|
||||
}
|
||||
|
||||
const telegramKeepAlive = 30 * time.Second
|
||||
|
||||
func dialToTelegram(dcIdx int16, timeout time.Duration) (net.Conn, error) {
|
||||
if dcIdx < 0 || dcIdx >= 5 {
|
||||
return nil, errors.New("Incorrect DC IDX")
|
||||
}
|
||||
|
||||
dialer := net.Dialer{Timeout: timeout}
|
||||
rawConn, err := dialer.Dial("tcp", telegramDCIPs[dcIdx])
|
||||
conn := rawConn.(*net.TCPConn)
|
||||
if err != nil {
|
||||
return nil, errors.Annotate(err, "Cannot dial")
|
||||
}
|
||||
|
||||
if err := conn.SetKeepAlive(true); err != nil {
|
||||
return nil, errors.Annotate(err, "Cannot establish keepalive connection")
|
||||
}
|
||||
if err := conn.SetKeepAlivePeriod(telegramKeepAlive); err != nil {
|
||||
return nil, errors.Annotate(err, "Cannot set keepalive timeout")
|
||||
}
|
||||
|
||||
return conn, nil
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package proxy
|
||||
|
||||
import (
|
||||
"io"
|
||||
"net"
|
||||
"time"
|
||||
)
|
||||
|
||||
type TimeoutReadWriteCloser struct {
|
||||
conn net.Conn
|
||||
readTimeout time.Duration
|
||||
writeTimeout time.Duration
|
||||
}
|
||||
|
||||
func (t *TimeoutReadWriteCloser) Read(p []byte) (int, error) {
|
||||
t.conn.SetReadDeadline(time.Now().Add(t.readTimeout))
|
||||
return t.conn.Read(p)
|
||||
}
|
||||
|
||||
func (t *TimeoutReadWriteCloser) Write(p []byte) (int, error) {
|
||||
t.conn.SetWriteDeadline(time.Now().Add(t.writeTimeout))
|
||||
return t.conn.Write(p)
|
||||
}
|
||||
|
||||
func (t *TimeoutReadWriteCloser) Close() error {
|
||||
return t.conn.Close()
|
||||
}
|
||||
|
||||
func newTimeoutReadWriteCloser(conn net.Conn, readTimeout, writeTimeout time.Duration) io.ReadWriteCloser {
|
||||
return &TimeoutReadWriteCloser{
|
||||
conn: conn,
|
||||
readTimeout: readTimeout,
|
||||
writeTimeout: writeTimeout,
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user