mirror of
https://github.com/ScuroNeko/mtg.git
synced 2026-09-01 05:24:02 +03:00
Working version
This commit is contained in:
9seconds
@@ -0,0 +1,52 @@
|
||||
package server
|
||||
|
||||
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) {
|
||||
c.rest.Write(c.crypt.Encrypt(p))
|
||||
newP := c.rest.Bytes()[:len(p)]
|
||||
n, err = c.conn.Write(newP)
|
||||
c.rest = bytes.NewBuffer(c.rest.Bytes()[n:])
|
||||
return
|
||||
}
|
||||
|
||||
func (c *CipherReadWriteCloser) Close() error {
|
||||
var err1 error
|
||||
if c.rest.Len() > 0 {
|
||||
_, err1 = c.conn.Write(c.rest.Bytes())
|
||||
}
|
||||
err2 := c.conn.Close()
|
||||
|
||||
if err2 != nil {
|
||||
return err2
|
||||
}
|
||||
return err1
|
||||
}
|
||||
|
||||
func newCipherReadWriteCloser(conn io.ReadWriteCloser, crypt Cipher) io.ReadWriteCloser {
|
||||
return &CipherReadWriteCloser{
|
||||
conn: conn,
|
||||
crypt: crypt,
|
||||
rest: &bytes.Buffer{},
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
package server
|
||||
|
||||
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 server
|
||||
|
||||
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,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,184 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"strconv"
|
||||
"sync"
|
||||
|
||||
"github.com/9seconds/mtg/obfuscated2"
|
||||
"github.com/juju/errors"
|
||||
uuid "github.com/satori/go.uuid"
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
type Server struct {
|
||||
ip net.IP
|
||||
port int
|
||||
secret []byte
|
||||
logger *zap.SugaredLogger
|
||||
lsock net.Listener
|
||||
ctx context.Context
|
||||
}
|
||||
|
||||
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,
|
||||
)
|
||||
|
||||
clientCipher, dc := 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
|
||||
// }
|
||||
|
||||
tgConn, tgCipher := 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 func() {
|
||||
buf := make([]byte, 128)
|
||||
for {
|
||||
n, err := conn.Read(buf)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
decrypted := clientCipher.Decrypt(buf[:n])
|
||||
encrypted := tgCipher.Encrypt(decrypted)
|
||||
tgConn.Write(encrypted)
|
||||
}
|
||||
}()
|
||||
go func() {
|
||||
buf := make([]byte, 128)
|
||||
for {
|
||||
n, err := tgConn.Read(buf)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
decrypted := tgCipher.Decrypt(buf[:n])
|
||||
encrypted := clientCipher.Encrypt(decrypted)
|
||||
conn.Write(encrypted)
|
||||
}
|
||||
}()
|
||||
// go func() {
|
||||
// buf := make([]byte, 128)
|
||||
// for {
|
||||
// n, err := conn.
|
||||
// }
|
||||
// defer wait.Done()
|
||||
// io.Copy(tgConn, clientConn)
|
||||
// }()
|
||||
// go func() {
|
||||
// defer wait.Done()
|
||||
// io.Copy(clientConn, tgConn)
|
||||
// }()
|
||||
<-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) (Cipher, int16) {
|
||||
frame, err := obfuscated2.ExtractFrame(conn)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
// return nil, 0, errors.Annotate(err, "Cannot create client stream")
|
||||
}
|
||||
|
||||
obfs2, dc, err := obfuscated2.ParseObfuscated2ClientFrame(s.secret, frame)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
// return nil, 0, errors.Annotate(err, "Cannot create client stream")
|
||||
}
|
||||
|
||||
return obfs2, dc
|
||||
|
||||
// cipherConn := newCipherReadWriteCloser(conn, obfs2)
|
||||
// ctxConn := newCtxReadWriteCloser(cipherConn, ctx, cancel)
|
||||
// // logConn := newLogReadWriteCloser(ctxConn, s.logger, socketID, "client")
|
||||
|
||||
// return ctxConn, dc, nil
|
||||
}
|
||||
|
||||
func (s *Server) getTelegramStream(dc int16, ctx context.Context, cancel context.CancelFunc, socketID string) (io.ReadWriteCloser, Cipher) {
|
||||
socket, err := dialToTelegram(dc)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
// return nil, errors.Annotate(err, "Cannot dial")
|
||||
}
|
||||
|
||||
obfs2, frame := obfuscated2.MakeTelegramObfuscated2Frame()
|
||||
if n, err := socket.Write(frame); err != nil || n != len(frame) {
|
||||
fmt.Println(err)
|
||||
// return nil, errors.Annotate(err, "Cannot write hadnshake frame")
|
||||
}
|
||||
|
||||
return socket, obfs2
|
||||
|
||||
// cipherConn := newCipherReadWriteCloser(socket, obfs2)
|
||||
// ctxConn := newCtxReadWriteCloser(cipherConn, ctx, cancel)
|
||||
// logConn := newLogReadWriteCloser(ctxConn, s.logger, socketID, "telegram")
|
||||
|
||||
// return logConn, nil
|
||||
}
|
||||
|
||||
func NewServer(ip net.IP, port int, secret []byte, logger *zap.SugaredLogger) *Server {
|
||||
return &Server{
|
||||
ip: ip,
|
||||
port: port,
|
||||
secret: secret,
|
||||
ctx: context.Background(),
|
||||
logger: logger,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
package server
|
||||
|
||||
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) (net.Conn, error) {
|
||||
if dcIdx < 0 || dcIdx >= 5 {
|
||||
return nil, errors.New("Incorrect DC IDX")
|
||||
}
|
||||
|
||||
conn, err := net.Dial("tcp", telegramDCIPs[dcIdx])
|
||||
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
|
||||
}
|
||||
Reference in New Issue
Block a user