ScuroNeko/mtg
1
0
Fork 0
mirror of https://github.com/ScuroNeko/mtg.git synced 2026-09-01 00:44:02 +03:00
Code Issues Packages Projects Releases Wiki Activity

Direct proxy works

Browse Source
This commit is contained in:
9seconds
2019-09-04 10:19:01 +03:00
parent 07985cf418
commit 2492a47d0a
87 changed files with 1883 additions and 1447 deletions
Download Patch File Download Diff File Expand all files Collapse all files
_telegram/dialer.go
+52
View File
@@ -0,0 +1,52 @@
package telegram
import (
"context"
"net"
"time"
"github.com/juju/errors"
"github.com/9seconds/mtg/config"
"github.com/9seconds/mtg/wrappers"
)
const telegramDialTimeout = 10 * time.Second
type tgDialer struct {
net.Dialer
conf *config.Config
}
func (t *tgDialer) dial(addr string) (net.Conn, error) {
conn, err := t.Dialer.Dial("tcp", addr)
if err != nil {
return nil, errors.Annotate(err, "Cannot connect to Telegram")
}
tcpSocket := conn.(*net.TCPConn)
if err = tcpSocket.SetNoDelay(true); err != nil {
return nil, errors.Annotate(err, "Cannot set NO_DELAY to Telegram")
}
if err = tcpSocket.SetReadBuffer(t.conf.WriteBufferSize); err != nil {
return nil, errors.Annotate(err, "Cannot set read buffer size on telegram socket")
}
if err = tcpSocket.SetWriteBuffer(t.conf.ReadBufferSize); err != nil {
return nil, errors.Annotate(err, "Cannot set write buffer size on telegram socket")
}
return conn, nil
}
func (t *tgDialer) dialRWC(ctx context.Context, cancel context.CancelFunc,
addr, connID string) (wrappers.StreamReadWriteCloser, error) {
conn, err := t.dial(addr)
if err != nil {
return nil, err
}
tgConn := wrappers.NewConn(ctx, cancel, conn, connID,
wrappers.ConnPurposeTelegram, t.conf.PublicIPv4, t.conf.PublicIPv6)
return tgConn, nil
}
_telegram/direct.go
+79
View File
@@ -0,0 +1,79 @@
package telegram
import (
"context"
"net"
"github.com/juju/errors"
"github.com/9seconds/mtg/config"
"github.com/9seconds/mtg/mtproto"
"github.com/9seconds/mtg/obfuscated2"
"github.com/9seconds/mtg/wrappers"
)
const (
directV4DefaultIdx = 1
directV6DefaultIdx = 1
)
var (
directV4Addresses = map[int16][]string{
0: {"149.154.175.50:443"},
1: {"149.154.167.51:443"},
2: {"149.154.175.100:443"},
3: {"149.154.167.91:443"},
4: {"149.154.171.5:443"},
}
directV6Addresses = map[int16][]string{
0: {"[2001:b28:f23d:f001::a]:443"},
1: {"[2001:67c:04e8:f002::a]:443"},
2: {"[2001:b28:f23d:f003::a]:443"},
3: {"[2001:67c:04e8:f004::a]:443"},
4: {"[2001:b28:f23f:f005::a]:443"},
}
)
type directTelegram struct {
baseTelegram
}
func (t *directTelegram) Dial(ctx context.Context, cancel context.CancelFunc,
connID string, connOpts *mtproto.ConnectionOpts) (wrappers.StreamReadWriteCloser, error) {
dc := connOpts.DC
if dc < 0 {
dc = -dc
} else if dc == 0 {
dc = 1
}
return t.baseTelegram.dial(ctx, cancel, dc-1, connID, connOpts.ConnectionProto)
}
func (t *directTelegram) Init(connOpts *mtproto.ConnectionOpts,
conn wrappers.StreamReadWriteCloser) (wrappers.Wrap, error) {
obfs2, frame := obfuscated2.MakeTelegramObfuscated2Frame(connOpts)
if _, err := conn.Write(frame); err != nil {
return nil, errors.Annotate(err, "Cannot write hadnshake frame")
}
return wrappers.NewStreamCipher(conn, obfs2.Encryptor, obfs2.Decryptor), nil
}
// NewDirectTelegram returns Telegram instance which connects directly
// to Telegram bypassing middleproxies.
func NewDirectTelegram(conf *config.Config) Telegram {
return &directTelegram{
baseTelegram: baseTelegram{
dialer: tgDialer{
Dialer: net.Dialer{Timeout: telegramDialTimeout},
conf: conf,
},
v4DefaultIdx: directV4DefaultIdx,
v6DefaultIdx: directV6DefaultIdx,
v4Addresses: directV4Addresses,
v6Addresses: directV6Addresses,
},
}
}
_telegram/middle.go
+139
View File
@@ -0,0 +1,139 @@
package telegram
import (
"io"
"net"
"net/http"
"sync"
"github.com/juju/errors"
"github.com/9seconds/mtg/config"
"github.com/9seconds/mtg/mtproto"
"github.com/9seconds/mtg/mtproto/rpc"
"github.com/9seconds/mtg/wrappers"
)
type middleTelegram struct {
middleTelegramCaller
conf *config.Config
}
func (t *middleTelegram) Init(connOpts *mtproto.ConnectionOpts,
conn wrappers.StreamReadWriteCloser) (wrappers.Wrap, error) {
rpcNonceConn := wrappers.NewMTProtoFrame(conn, rpc.SeqNoNonce)
rpcNonceReq, err := t.sendRPCNonceRequest(rpcNonceConn)
if err != nil {
return nil, err
}
rpcNonceResp, err := t.receiveRPCNonceResponse(rpcNonceConn, rpcNonceReq)
if err != nil {
return nil, err
}
secureConn := wrappers.NewMiddleProxyCipher(conn, rpcNonceReq, rpcNonceResp, t.proxySecret)
frameConn := wrappers.NewMTProtoFrame(secureConn, rpc.SeqNoHandshake)
rpcHandshakeReq, err := t.sendRPCHandshakeRequest(frameConn)
if err != nil {
return nil, err
}
_, err = t.receiveRPCHandshakeResponse(frameConn, rpcHandshakeReq)
if err != nil {
return nil, err
}
proxyConn, err := wrappers.NewMTProtoProxy(frameConn, connOpts, t.conf.AdTag)
if err != nil {
return nil, err
}
proxyConn.Logger().Infow("Telegram connection initialized")
return proxyConn, nil
}
func (t *middleTelegram) sendRPCNonceRequest(conn io.Writer) (*rpc.NonceRequest, error) {
rpcNonceReq, err := rpc.NewNonceRequest(t.proxySecret)
if err != nil {
return nil, errors.Annotate(err, "Cannot create RPC nonce request")
}
if _, err = conn.Write(rpcNonceReq.Bytes()); err != nil {
return nil, errors.Annotate(err, "Cannot send RPC nonce request")
}
return rpcNonceReq, nil
}
func (t *middleTelegram) receiveRPCNonceResponse(conn wrappers.PacketReader,
req *rpc.NonceRequest) (*rpc.NonceResponse, error) {
packet, err := conn.Read()
if err != nil {
return nil, errors.Annotate(err, "Cannot read RPC nonce response")
}
rpcNonceResp, err := rpc.NewNonceResponse(packet)
if err != nil {
return nil, errors.Annotate(err, "Cannot initialize RPC nonce response")
}
if err = rpcNonceResp.Valid(req); err != nil {
return nil, errors.Annotate(err, "Invalid RPC nonce response")
}
return rpcNonceResp, nil
}
func (t *middleTelegram) sendRPCHandshakeRequest(conn io.Writer) (*rpc.HandshakeRequest, error) {
req := rpc.NewHandshakeRequest()
if _, err := conn.Write(req.Bytes()); err != nil {
return nil, errors.Annotate(err, "Cannot send RPC handshake request")
}
return req, nil
}
func (t *middleTelegram) receiveRPCHandshakeResponse(conn wrappers.PacketReader,
req *rpc.HandshakeRequest) (*rpc.HandshakeResponse, error) {
packet, err := conn.Read()
if err != nil {
return nil, errors.Annotate(err, "Cannot read RPC handshake response")
}
rpcHandshakeResp, err := rpc.NewHandshakeResponse(packet)
if err != nil {
return nil, errors.Annotate(err, "Cannot initialize RPC handshake response")
}
if err = rpcHandshakeResp.Valid(req); err != nil {
return nil, errors.Annotate(err, "Invalid RPC handshake response")
}
return rpcHandshakeResp, nil
}
// NewMiddleTelegram creates new instance of Telegram which works with
// middle proxies.
func NewMiddleTelegram(conf *config.Config) Telegram {
tg := &middleTelegram{
middleTelegramCaller: middleTelegramCaller{
baseTelegram: baseTelegram{
dialer: tgDialer{
Dialer: net.Dialer{Timeout: telegramDialTimeout},
conf: conf,
},
},
httpClient: &http.Client{
Timeout: middleTelegramHTTPClientTimeout,
},
dialerMutex: &sync.RWMutex{},
},
conf: conf,
}
if err := tg.update(); err != nil {
panic(err)
}
go tg.autoUpdate()
return tg
}
_telegram/middle_caller.go
+191
View File
@@ -0,0 +1,191 @@
package telegram
import (
"bufio"
"context"
"io/ioutil"
"net"
"net/http"
"regexp"
"strconv"
"strings"
"sync"
"time"
"github.com/juju/errors"
"go.uber.org/zap"
"github.com/9seconds/mtg/mtproto"
"github.com/9seconds/mtg/wrappers"
)
const (
middleTelegramAutoUpdateInterval = 6 * time.Hour
middleTelegramHTTPClientTimeout = 30 * time.Second
tgAddrProxySecret = "https://core.telegram.org/getProxySecret" // nolint: gas
tgAddrProxyV4 = "https://core.telegram.org/getProxyConfig" // nolint: gas
tgAddrProxyV6 = "https://core.telegram.org/getProxyConfigV6" // nolint: gas
tgUserAgent = "mtg"
)
var middleTelegramProxyConfigSplitter = regexp.MustCompile(`\s+`)
type middleTelegramCaller struct {
baseTelegram
proxySecret []byte
dialerMutex *sync.RWMutex
httpClient *http.Client
}
func (t *middleTelegramCaller) Dial(ctx context.Context, cancel context.CancelFunc, connID string,
connOpts *mtproto.ConnectionOpts) (wrappers.StreamReadWriteCloser, error) {
dc := connOpts.DC
if dc == 0 {
dc = 1
}
t.dialerMutex.RLock()
defer t.dialerMutex.RUnlock()
return t.baseTelegram.dial(ctx, cancel, dc, connID, connOpts.ConnectionProto)
}
func (t *middleTelegramCaller) autoUpdate() {
for range time.Tick(middleTelegramAutoUpdateInterval) {
if err := t.update(); err != nil {
zap.S().Warnw("Cannot update from Telegram", "error", err)
}
}
}
func (t *middleTelegramCaller) update() error {
secret, err := t.getTelegramProxySecret()
if err != nil {
return errors.Annotate(err, "Cannot get proxy secret")
}
v4Addresses, v4DefaultIdx, err := t.getTelegramAddresses(tgAddrProxyV4)
if err != nil {
return errors.Annotate(err, "Cannot get ipv4 addresses")
}
v6Addresses, v6DefaultIdx, err := t.getTelegramAddresses(tgAddrProxyV6)
if err != nil {
return errors.Annotate(err, "Cannot get ipv6 addresses")
}
t.dialerMutex.Lock()
t.proxySecret = secret
t.v4DefaultIdx = v4DefaultIdx
t.v6DefaultIdx = v6DefaultIdx
t.v4Addresses = v4Addresses
t.v6Addresses = v6Addresses
t.dialerMutex.Unlock()
zap.S().Infow("Telegram middle proxy data has been updated")
return nil
}
func (t *middleTelegramCaller) getTelegramProxySecret() ([]byte, error) {
resp, err := t.call(tgAddrProxySecret)
if err != nil {
return nil, errors.Annotate(err, "Cannot access telegram server")
}
defer resp.Body.Close() // nolint: errcheck
secret, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, errors.Annotate(err, "Cannot read response")
}
return secret, nil
}
func (t *middleTelegramCaller) getTelegramAddresses(url string) (map[int16][]string, int16, error) { // nolint: gocyclo
resp, err := t.call(url)
if err != nil {
return nil, 0, errors.Annotate(err, "Cannot access telegram server")
}
defer resp.Body.Close() // nolint: errcheck
scanner := bufio.NewScanner(resp.Body)
data := map[int16][]string{}
var defaultIdx int16 = 1
for scanner.Scan() {
text := strings.TrimSpace(scanner.Text())
switch {
case strings.HasPrefix(text, "#"):
continue
case strings.HasPrefix(text, "proxy_for"):
addr, idx, err2 := t.parseProxyFor(text)
if err2 != nil {
return nil, 0, errors.Annotate(err2, "Cannot parse 'proxy_for' section")
}
if addresses, ok := data[idx]; ok {
data[idx] = append(addresses, addr)
} else {
data[idx] = []string{addr}
}
case strings.HasPrefix(text, "default"):
idx, err2 := t.parseDefault(text)
if err2 != nil {
return nil, 0, errors.Annotate(err2, "Cannot parse 'default' section")
}
defaultIdx = idx
default:
return nil, 0, errors.Errorf("Unknown config string '%s'", text)
}
}
err = scanner.Err()
if err != nil {
return nil, 0, errors.Annotate(err, "Cannot read response from the telegram")
}
return data, defaultIdx, nil
}
func (t *middleTelegramCaller) parseProxyFor(text string) (string, int16, error) {
chunks := middleTelegramProxyConfigSplitter.Split(text, 3)
if len(chunks) != 3 || chunks[0] != "proxy_for" {
return "", 0, errors.Errorf("Incorrect config '%s'", text)
}
dcIdx, err := strconv.ParseInt(chunks[1], 10, 16)
if err != nil {
return "", 0, errors.Annotatef(err, "Incorrect config '%s'", text)
}
addr := strings.TrimRight(chunks[2], ";")
if _, _, err = net.SplitHostPort(addr); err != nil {
return "", 0, errors.Annotatef(err, "Incorrect config '%s'", text)
}
return addr, int16(dcIdx), nil
}
func (t *middleTelegramCaller) parseDefault(text string) (int16, error) {
chunks := middleTelegramProxyConfigSplitter.Split(text, 2)
if len(chunks) != 2 || chunks[0] != "default" {
return 0, errors.Errorf("Incorrect config '%s'", text)
}
dcIdxString := strings.TrimRight(chunks[1], ";")
dcIdx, err := strconv.ParseInt(dcIdxString, 10, 16)
if err != nil {
return 0, errors.Annotatef(err, "Incorrect config '%s'", text)
}
return int16(dcIdx), nil
}
func (t *middleTelegramCaller) call(url string) (*http.Response, error) {
req, _ := http.NewRequest("GET", url, nil) // nolint: gosec
req.Header.Set("Accept", "text/plain")
req.Header.Set("User-Agent", tgUserAgent)
return t.httpClient.Do(req)
}
_telegram/telegram.go
+68
View File
@@ -0,0 +1,68 @@
package telegram
import (
"context"
"math/rand"
"github.com/juju/errors"
"github.com/9seconds/mtg/mtproto"
"github.com/9seconds/mtg/wrappers"
)
// Telegram is an interface for different Telegram work modes.
type Telegram interface {
Dial(context.Context, context.CancelFunc, string, *mtproto.ConnectionOpts) (wrappers.StreamReadWriteCloser, error)
Init(*mtproto.ConnectionOpts, wrappers.StreamReadWriteCloser) (wrappers.Wrap, error)
}
type baseTelegram struct {
dialer tgDialer
v4DefaultIdx int16
v6DefaultIdx int16
v4Addresses map[int16][]string
v6Addresses map[int16][]string
}
func (b *baseTelegram) dial(ctx context.Context, cancel context.CancelFunc, dcIdx int16, connID string,
proto mtproto.ConnectionProtocol) (wrappers.StreamReadWriteCloser, error) {
addrs := make([]string, 2)
if proto&mtproto.ConnectionProtocolIPv6 != 0 {
if addr := b.chooseAddress(b.v6Addresses, dcIdx, b.v6DefaultIdx); addr != "" {
addrs = append(addrs, addr)
}
}
if proto&mtproto.ConnectionProtocolIPv4 != 0 {
if addr := b.chooseAddress(b.v4Addresses, dcIdx, b.v4DefaultIdx); addr != "" {
addrs = append(addrs, addr)
}
}
for _, addr := range addrs {
if conn, err := b.dialer.dialRWC(ctx, cancel, addr, connID); err == nil {
return conn, err
}
}
return nil, errors.New("Cannot connect to Telegram")
}
func (b *baseTelegram) chooseAddress(addresses map[int16][]string, idx, defaultIdx int16) string {
if addr, ok := addresses[idx]; ok {
return b.chooseRandomAddress(addr)
} else if addr, ok := addresses[defaultIdx]; ok {
return b.chooseRandomAddress(addr)
}
return ""
}
func (b *baseTelegram) chooseRandomAddress(addresses []string) string {
if len(addresses) > 0 {
return addresses[rand.Intn(len(addresses))]
}
return ""
}