Add obfuscated2 server handshake

mtglib/internal/obfuscated2/client_handshake.go

@@ -8,6 +8,33 @@ import (
 	"io"
 )
 
+type clientHandhakeFrame struct {
+	handshakeFrame
+}
+
+func (c *clientHandhakeFrame) decryptor(secret []byte) cipher.Stream {
+	hasher := acquireSha256Hasher()
+	defer releaseSha256Hasher(hasher)
+
+	hasher.Write(c.key()) // nolint: errcheck
+	hasher.Write(secret)  // nolint: errcheck
+
+	return makeAesCtr(hasher.Sum(nil), c.iv())
+}
+
+func (c *clientHandhakeFrame) encryptor(secret []byte) cipher.Stream {
+	arr := clientHandhakeFrame{}
+	invertByteSlices(arr.data[:], c.data[:])
+
+	hasher := acquireSha256Hasher()
+	defer releaseSha256Hasher(hasher)
+
+	hasher.Write(arr.key()) // nolint: errcheck
+	hasher.Write(secret)    // nolint: errcheck
+
+	return makeAesCtr(hasher.Sum(nil), arr.iv())
+}
+
 func ClientHandshake(secret []byte, reader io.Reader) (int, cipher.Stream, cipher.Stream, error) {
 	handshake := clientHandhakeFrame{}
 

mtglib/internal/obfuscated2/client_handshake_frame.go

@@ -1,30 +0,0 @@
-package obfuscated2
-
-import "crypto/cipher"
-
-type clientHandhakeFrame struct {
-	handshakeFrame
-}
-
-func (c *clientHandhakeFrame) decryptor(secret []byte) cipher.Stream {
-	hasher := acquireSha256Hasher()
-	defer releaseSha256Hasher(hasher)
-
-	hasher.Write(c.key()) // nolint: errcheck
-	hasher.Write(secret)  // nolint: errcheck
-
-	return makeAesCtr(hasher.Sum(nil), c.iv())
-}
-
-func (c *clientHandhakeFrame) encryptor(secret []byte) cipher.Stream {
-	arr := clientHandhakeFrame{}
-	invertByteSlices(arr.data[:], c.data[:])
-
-	hasher := acquireSha256Hasher()
-	defer releaseSha256Hasher(hasher)
-
-	hasher.Write(arr.key()) // nolint: errcheck
-	hasher.Write(secret)    // nolint: errcheck
-
-	return makeAesCtr(hasher.Sum(nil), arr.iv())
-}

mtglib/internal/obfuscated2/conn.go

@@ -14,7 +14,7 @@ type Conn struct {
 	writeBuf []byte
 }
 
-func (c Conn) Read(p []byte) (int, error) {
+func (c *Conn) Read(p []byte) (int, error) {
 	n, err := c.Conn.Read(p)
 	if err != nil {
 		return n, err // nolint: wrapcheck
@@ -25,9 +25,9 @@ func (c Conn) Read(p []byte) (int, error) {
 	return n, nil
 }
 
-func (c Conn) Write(p []byte) (int, error) {
+func (c *Conn) Write(p []byte) (int, error) {
 	c.writeBuf = append(c.writeBuf[:0], p...)
-	c.Encryptor.XORKeyStream(c.writeBuf, c.writeBuf)
+	c.Encryptor.XORKeyStream(c.writeBuf, p)
 
 	return c.Conn.Write(c.writeBuf)
 }

mtglib/internal/obfuscated2/server_handshake.go

@@ -0,0 +1,68 @@
+package obfuscated2
+
+import (
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/binary"
+	"fmt"
+	"net"
+)
+
+type serverHandshakeFrame struct {
+	handshakeFrame
+}
+
+func (s *serverHandshakeFrame) decryptor() cipher.Stream {
+	return makeAesCtr(s.key(), s.iv())
+}
+
+func (s *serverHandshakeFrame) encryptor() cipher.Stream {
+	arr := serverHandshakeFrame{}
+	invertByteSlices(arr.data[:], s.data[:])
+
+	return makeAesCtr(arr.key(), arr.iv())
+}
+
+func ServerHandshake(conn net.Conn) (cipher.Stream, cipher.Stream, error) {
+	handshake := generateServerHanshakeFrame()
+	copyHandshake := handshake
+	encryptor := handshake.encryptor()
+	decryptor := handshake.decryptor()
+
+	encryptor.XORKeyStream(handshake.data[:], handshake.data[:])
+	copy(handshake.key(), copyHandshake.key())
+	copy(handshake.iv(), copyHandshake.iv())
+
+	if _, err := conn.Write(handshake.data[:]); err != nil {
+		return nil, nil, fmt.Errorf("cannot send a handshake frame to telegram: %w", err)
+	}
+
+	return encryptor, decryptor, nil
+}
+
+func generateServerHanshakeFrame() serverHandshakeFrame {
+	frame := serverHandshakeFrame{}
+
+	for {
+		if _, err := rand.Read(frame.data[:]); err != nil {
+			panic(err)
+		}
+
+		if frame.data[0] == 0xef {
+			continue
+		}
+
+		switch binary.LittleEndian.Uint32(frame.data[:4]) {
+		case 0x44414548, 0x54534f50, 0x20544547, 0x4954504f, 0xeeeeeeee:
+			continue
+		}
+
+		if (frame.data[4] | frame.data[5] | frame.data[6] | frame.data[7]) == 0 {
+			continue
+		}
+
+		copy(frame.connectionType(), handshakeConnectionType)
+
+		return frame
+	}
+}