Przeglądaj źródła

Integrate obfuscation package

tags/v2.1.11^2^2
9seconds 2 miesięcy temu
rodzic
commit
140e9dfc2e
2 zmienionych plików z 36 dodań i 29 usunięć
  1. 10
    3
      mtglib/internal/dc/addr.go
  2. 26
    26
      mtglib/proxy.go

+ 10
- 3
mtglib/internal/dc/addr.go Wyświetl plik

1
 package dc
1
 package dc
2
 
2
 
3
+import (
4
+	"fmt"
5
+
6
+	"github.com/9seconds/mtg/v2/mtglib/internal/obfuscation"
7
+)
8
+
3
 type Addr struct {
9
 type Addr struct {
4
-	Network string
5
-	Address string
10
+	Network    string
11
+	Address    string
12
+	Obfuscator obfuscation.Obfuscator
6
 }
13
 }
7
 
14
 
8
 func (d Addr) String() string {
15
 func (d Addr) String() string {
9
-	return d.Address
16
+	return fmt.Sprintf("addr=%s, secret=%v", d.Address, d.Obfuscator.Secret)
10
 }
17
 }

+ 26
- 26
mtglib/proxy.go Wyświetl plik

13
 	"github.com/9seconds/mtg/v2/mtglib/internal/dc"
13
 	"github.com/9seconds/mtg/v2/mtglib/internal/dc"
14
 	"github.com/9seconds/mtg/v2/mtglib/internal/faketls"
14
 	"github.com/9seconds/mtg/v2/mtglib/internal/faketls"
15
 	"github.com/9seconds/mtg/v2/mtglib/internal/faketls/record"
15
 	"github.com/9seconds/mtg/v2/mtglib/internal/faketls/record"
16
-	"github.com/9seconds/mtg/v2/mtglib/internal/obfuscated2"
16
+	"github.com/9seconds/mtg/v2/mtglib/internal/obfuscation"
17
 	"github.com/9seconds/mtg/v2/mtglib/internal/relay"
17
 	"github.com/9seconds/mtg/v2/mtglib/internal/relay"
18
 	"github.com/panjf2000/ants/v2"
18
 	"github.com/panjf2000/ants/v2"
19
 )
19
 )
29
 	domainFrontingPort       int
29
 	domainFrontingPort       int
30
 	workerPool               *ants.PoolWithFunc
30
 	workerPool               *ants.PoolWithFunc
31
 	telegram                 *dc.Telegram
31
 	telegram                 *dc.Telegram
32
+	clientObfuscatror        obfuscation.Obfuscator
32
 
33
 
33
 	secret          Secret
34
 	secret          Secret
34
 	network         Network
35
 	network         Network
70
 		return
71
 		return
71
 	}
72
 	}
72
 
73
 
73
-	if err := p.doObfuscated2Handshake(ctx); err != nil {
74
-		p.logger.InfoError("obfuscated2 handshake is failed", err)
74
+	if err := p.doObfuscatedHandshake(ctx); err != nil {
75
+		p.logger.InfoError("obfuscated handshake is failed", err)
75
 
76
 
76
 		return
77
 		return
77
 	}
78
 	}
201
 	return true
202
 	return true
202
 }
203
 }
203
 
204
 
204
-func (p *Proxy) doObfuscated2Handshake(ctx *streamContext) error {
205
-	dc, encryptor, decryptor, err := obfuscated2.ClientHandshake(p.secret.Key[:], ctx.clientConn)
205
+func (p *Proxy) doObfuscatedHandshake(ctx *streamContext) error {
206
+	dc, conn, err := p.clientObfuscatror.ReadHandshake(ctx.clientConn)
206
 	if err != nil {
207
 	if err != nil {
207
 		return fmt.Errorf("cannot process client handshake: %w", err)
208
 		return fmt.Errorf("cannot process client handshake: %w", err)
208
 	}
209
 	}
209
 
210
 
210
 	ctx.dc = dc
211
 	ctx.dc = dc
212
+	ctx.clientConn = conn
211
 	ctx.logger = ctx.logger.BindInt("dc", dc)
213
 	ctx.logger = ctx.logger.BindInt("dc", dc)
212
-	ctx.clientConn = obfuscated2.Conn{
213
-		Conn:      ctx.clientConn,
214
-		Encryptor: encryptor,
215
-		Decryptor: decryptor,
216
-	}
217
 
214
 
218
 	return nil
215
 	return nil
219
 }
216
 }
223
 
220
 
224
 	addresses := p.telegram.GetAddresses(dcid)
221
 	addresses := p.telegram.GetAddresses(dcid)
225
 	if len(addresses) == 0 && p.allowFallbackOnUnknownDC {
222
 	if len(addresses) == 0 && p.allowFallbackOnUnknownDC {
226
-		ctx.logger = ctx.logger.BindInt("fallback_dc", dc.DefaultDC)
223
+		ctx.logger = ctx.logger.BindInt("original_dc", dcid)
227
 		ctx.logger.Warning("unknown DC, fallbacks")
224
 		ctx.logger.Warning("unknown DC, fallbacks")
225
+		ctx.dc = dc.DefaultDC
228
 		addresses = p.telegram.GetAddresses(dc.DefaultDC)
226
 		addresses = p.telegram.GetAddresses(dc.DefaultDC)
229
 	}
227
 	}
230
 
228
 
231
-	var conn essentials.Conn
232
-	var err error
229
+	var (
230
+		conn      essentials.Conn
231
+		err       error
232
+		foundAddr dc.Addr
233
+	)
233
 
234
 
234
 	for _, addr := range addresses {
235
 	for _, addr := range addresses {
235
 		conn, err = p.network.Dial(addr.Network, addr.Address)
236
 		conn, err = p.network.Dial(addr.Network, addr.Address)
236
 		if err == nil {
237
 		if err == nil {
238
+			foundAddr = addr
237
 			break
239
 			break
238
 		}
240
 		}
239
 	}
241
 	}
241
 		return fmt.Errorf("no addresses to call: %w", err)
243
 		return fmt.Errorf("no addresses to call: %w", err)
242
 	}
244
 	}
243
 
245
 
244
-	encryptor, decryptor, err := obfuscated2.ServerHandshake(conn)
246
+	conn, err = foundAddr.Obfuscator.SendHandshake(conn, ctx.dc)
245
 	if err != nil {
247
 	if err != nil {
246
-		conn.Close() //nolint: errcheck
247
-
248
-		return fmt.Errorf("cannot perform obfuscated2 handshake: %w", err)
248
+		conn.Close()
249
+		return fmt.Errorf("cannot perform server handshake: %w", err)
249
 	}
250
 	}
250
 
251
 
251
-	ctx.telegramConn = obfuscated2.Conn{
252
-		Conn: connTraffic{
253
-			Conn:     conn,
254
-			streamID: ctx.streamID,
255
-			stream:   p.eventStream,
256
-			ctx:      ctx,
257
-		},
258
-		Encryptor: encryptor,
259
-		Decryptor: decryptor,
252
+	ctx.telegramConn = connTraffic{
253
+		Conn:     conn,
254
+		streamID: ctx.streamID,
255
+		stream:   p.eventStream,
256
+		ctx:      ctx,
260
 	}
257
 	}
261
 
258
 
262
 	p.eventStream.Send(ctx,
259
 	p.eventStream.Send(ctx,
320
 		tolerateTimeSkewness:     opts.getTolerateTimeSkewness(),
317
 		tolerateTimeSkewness:     opts.getTolerateTimeSkewness(),
321
 		allowFallbackOnUnknownDC: opts.AllowFallbackOnUnknownDC,
318
 		allowFallbackOnUnknownDC: opts.AllowFallbackOnUnknownDC,
322
 		telegram:                 tg,
319
 		telegram:                 tg,
320
+		clientObfuscatror: obfuscation.Obfuscator{
321
+			Secret: opts.Secret.Key[:],
322
+		},
323
 	}
323
 	}
324
 
324
 
325
 	pool, err := ants.NewPoolWithFunc(opts.getConcurrency(),
325
 	pool, err := ants.NewPoolWithFunc(opts.getConcurrency(),

Ładowanie…
Anuluj
Zapisz