Debug direct connection

client/direct.go

 	connOpts.ConnectionProto = mtproto.ConnectionProtocolAny
 	connOpts.ClientAddr = conn.RemoteAddr()
 
-	conn = wrappers.NewCtx(ctx, cancel, conn)
 	conn = wrappers.NewStreamCipher(conn, obfs2.Encryptor, obfs2.Decryptor)
+	conn = wrappers.NewCtx(ctx, cancel, conn)
 
 	return conn, connOpts, nil
 }

main.go

 
 	var server *proxy.Proxy
 	if len(conf.AdTag) == 0 {
+		zap.S().Infow("Use direct connection to Telegram")
 		server = proxy.NewProxyDirect(conf)
 	} else {
+		zap.S().Infow("Use middle proxy connection to Telegram")
 		server = proxy.NewProxyMiddle(conf)
 	}
 

obfuscated2/frame.go

 	"github.com/juju/errors"
 
 	"github.com/9seconds/mtg/mtproto"
-	"github.com/9seconds/mtg/utils"
 )
 
 // [frameOffsetFirst:frameOffsetKey:frameOffsetIV:frameOffsetMagic:frameOffsetDC:frameOffsetEnd]
 // Invert inverts frame for extracting encryption keys. Pkease check that link:
 // https://blog.susanka.eu/how-telegram-obfuscates-its-mtproto-traffic/
 func (f Frame) Invert() Frame {
-	return Frame(utils.ReverseBytes([]byte(f)))
+	reversed := make(Frame, FrameLen)
+	copy(reversed, f)
+
+	for i := 0; i < frameLenKey+frameLenIV; i++ {
+		reversed[frameOffsetFirst+i] = f[frameOffsetIV-1-i]
+	}
+
+	return reversed
 }
 
 // ExtractFrame extracts exact obfuscated2 handshake frame from given reader.

proxy/direct.go

 	return &Proxy{
 		conf: conf,
 		acceptCallback: func(ctx context.Context, cancel context.CancelFunc, clientSocket net.Conn,
-			connID string, wait *sync.WaitGroup, conf *config.Config) error {
+			connID string, wait *sync.WaitGroup, conf *config.Config) (io.Closer, io.Closer, error) {
 			client, opts, err := client.DirectInit(ctx, cancel, clientSocket, connID, conf)
 			if err != nil {
-				return errors.Annotate(err, "Cannot initialize client connection")
+				return nil, nil, errors.Annotate(err, "Cannot initialize client connection")
 			}
-			defer client.Close()
 
 			server, err := directTelegramStream(ctx, cancel, opts, connID, tg)
 			if err != nil {
-				return errors.Annotate(err, "Cannot initialize telegram connection")
+				return client, nil, errors.Annotate(err, "Cannot initialize telegram connection")
 			}
-			defer server.Close()
 
 			wait.Add(2)
 
 			go directPipe(client, server, wait)
 			go directPipe(server, client, wait)
 
-			return nil
+			return client, server, nil
 		},
 	}
 }

proxy/middle.go

 
 import (
 	"context"
+	"io"
 	"net"
 	"sync"
 
 	return &Proxy{
 		conf: conf,
 		acceptCallback: func(ctx context.Context, cancel context.CancelFunc, clientSocket net.Conn,
-			connID string, wait *sync.WaitGroup, conf *config.Config) error {
+			connID string, wait *sync.WaitGroup, conf *config.Config) (io.Closer, io.Closer, error) {
 			client, opts, err := client.MiddleInit(ctx, cancel, clientSocket, connID, conf)
 			if err != nil {
-				return errors.Annotate(err, "Cannot initialize client connection")
+				return nil, nil, errors.Annotate(err, "Cannot initialize client connection")
 			}
-			defer client.Close()
 
 			server, err := middleTelegramStream(ctx, cancel, opts, connID, tg)
 			if err != nil {
-				return errors.Annotate(err, "Cannot initialize telegram connection")
+				return client, nil, errors.Annotate(err, "Cannot initialize telegram connection")
 			}
-			defer server.Close()
 
 			wait.Add(2)
 
 			go middlePipe(client, server, wait, &opts.ReadHacks)
 			go middlePipe(server, client, wait, &opts.WriteHacks)
 
-			return nil
+			return client, server, nil
 		},
 	}
 }

proxy/proxy.go

 
 import (
 	"context"
+	"io"
 	"net"
 	"sync"
 
 	"github.com/9seconds/mtg/config"
 )
 
-type proxyAcceptCallback func(context.Context, context.CancelFunc, net.Conn, string, *sync.WaitGroup, *config.Config) error
+type proxyAcceptCallback func(context.Context, context.CancelFunc, net.Conn, string, *sync.WaitGroup, *config.Config) (io.Closer, io.Closer, error)
 
 type Proxy struct {
 	conf           *config.Config
 	ctx, cancel := context.WithCancel(context.Background())
 	wait := &sync.WaitGroup{}
 
-	if err := p.acceptCallback(ctx, cancel, conn, connID, wait, p.conf); err != nil {
+	client, server, err := p.acceptCallback(ctx, cancel, conn, connID, wait, p.conf)
+	defer func() {
+		if client != nil {
+			client.Close()
+		}
+		if server != nil {
+			server.Close()
+		}
+	}()
+	if err != nil {
 		log.Errorw("Cannot initialize connection", "error", err)
 		cancel()
 	}