Working version

obfuscated2/frame.go

@@ -0,0 +1,109 @@
+package obfuscated2
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/binary"
+	"io"
+
+	"github.com/juju/errors"
+)
+
+// https://blog.susanka.eu/how-telegram-obfuscates-its-mtproto-traffic/
+// [frameOffsetFirst:frameOffsetKey:frameOffsetIV:frameOffsetMagic:frameOffsetDC:frameOffsetEnd]
+const (
+	frameLenKey   = 32
+	frameLenIV    = 16
+	frameLenMagic = 4
+	frameLenDC    = 2
+
+	frameOffsetFirst = 8
+	frameOffsetKey   = frameOffsetFirst + frameLenKey
+	frameOffsetIV    = frameOffsetKey + frameLenIV
+	frameOffsetMagic = frameOffsetIV + frameLenMagic
+	frameOffsetDC    = frameOffsetMagic + frameLenDC
+
+	tgMagicByte = byte(239)
+
+	FrameLen = 64
+)
+
+var tgMagicBytes = []byte{tgMagicByte, tgMagicByte, tgMagicByte, tgMagicByte}
+
+type Frame []byte
+
+func (f Frame) Key() []byte {
+	return f[frameOffsetFirst:frameOffsetKey]
+}
+
+func (f Frame) IV() []byte {
+	return f[frameOffsetKey:frameOffsetIV]
+}
+
+func (f Frame) Magic() []byte {
+	return f[frameOffsetIV:frameOffsetMagic]
+}
+
+func (f Frame) DC() (n int16) {
+	buf := bytes.NewReader(f[frameOffsetMagic:frameOffsetDC])
+	binary.Read(buf, binary.LittleEndian, &n)
+
+	if n < 0 {
+		n = -n
+	} else if n == 0 {
+		n = 1
+	}
+
+	return n - 1
+}
+
+func (f Frame) Valid() bool {
+	return bytes.Equal(f.Magic(), tgMagicBytes)
+}
+
+func (f Frame) Invert() Frame {
+	reversed := make(Frame, FrameLen)
+	copy(reversed, f)
+
+	for i := 0; i < frameLenKey+frameLenIV; i++ {
+		reversed[frameOffsetFirst+i] = f[frameOffsetIV-1-i]
+	}
+
+	return reversed
+}
+
+func ExtractFrame(conn io.Reader) (Frame, error) {
+	buf := &bytes.Buffer{}
+	if _, err := io.CopyN(buf, conn, FrameLen); err != nil {
+		return nil, errors.Annotate(err, "Cannot extract obfuscated header")
+	}
+
+	return Frame(buf.Bytes()), nil
+}
+
+func generateFrame() Frame {
+	data := make(Frame, FrameLen)
+
+	for {
+		if _, err := rand.Read(data); err != nil {
+			continue
+		}
+		if data[0] == 0xef {
+			continue
+		}
+
+		val := (uint32(data[3]) << 24) | (uint32(data[2]) << 16) | (uint32(data[1]) << 8) | uint32(data[0])
+		if val == 0x44414548 || val == 0x54534f50 || val == 0x20544547 || val == 0x4954504f || val == 0xeeeeeeee {
+			continue
+		}
+
+		val = (uint32(data[7]) << 24) | (uint32(data[6]) << 16) | (uint32(data[5]) << 8) | uint32(data[4])
+		if val == 0x00000000 {
+			continue
+		}
+
+		copy(data.Magic(), tgMagicBytes)
+
+		return data
+	}
+}

obfuscated2/frame_test.go

@@ -0,0 +1,83 @@
+package obfuscated2
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFrameKey(t *testing.T) {
+	toCompare := make([]byte, 32)
+	for i := 0; i < 32; i++ {
+		toCompare[i] = byte(1)
+	}
+
+	assert.Equal(t, toCompare, makeFrame().Key())
+}
+
+func TestFrameIV(t *testing.T) {
+	toCompare := make([]byte, 16)
+	for i := 0; i < 16; i++ {
+		toCompare[i] = byte(2)
+	}
+
+	assert.Equal(t, toCompare, makeFrame().IV())
+}
+
+func TestFrameMagic(t *testing.T) {
+	toCompare := make([]byte, 4)
+	for i := 0; i < 4; i++ {
+		toCompare[i] = tgMagicByte
+	}
+
+	assert.Equal(t, toCompare, makeFrame().Magic())
+}
+
+func TestFrameDC(t *testing.T) {
+	assert.Equal(t, int16(771), makeFrame().DC())
+}
+
+func TestFrameValid(t *testing.T) {
+	frame := makeFrame()
+	assert.True(t, frame.Valid())
+
+	frame[8+32+16+2] = byte(3)
+	assert.False(t, frame.Valid())
+}
+
+func TestFrameInvert(t *testing.T) {
+	frame := makeFrame()
+	reversed := frame.Invert()
+
+	assert.Exactly(t, frame[:8], reversed[:8])
+	assert.Exactly(t, frame[56:], reversed[56:])
+
+	toCompare := make([]byte, 48)
+	for i := 0; i < 48; i++ {
+		toCompare[i] = frame[55-i]
+	}
+	assert.Equal(t, []byte(reversed[8:56]), toCompare)
+}
+
+func TestFrameGenerateValid(t *testing.T) {
+	assert.True(t, generateFrame().Valid())
+}
+
+func makeFrame() Frame {
+	f := make(Frame, FrameLen)
+
+	for i := 8; i < (8 + 32); i++ {
+		f[i] = byte(1)
+	}
+	for i := (8 + 32); i < (8 + 32 + 16); i++ {
+		f[i] = byte(2)
+	}
+	for i := (8 + 32 + 16); i < (8 + 32 + 16 + 4); i++ {
+		f[i] = tgMagicByte
+	}
+	for i := (8 + 32 + 16 + 4); i < (8 + 32 + 16 + 4 + 2); i++ {
+		f[i] = byte(3)
+	}
+
+	return f
+}

obfuscated2/obfuscated2.go

@@ -0,0 +1,79 @@
+package obfuscated2
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/sha256"
+
+	"github.com/juju/errors"
+)
+
+type Obfuscated2 struct {
+	decryptor cipher.Stream
+	encryptor cipher.Stream
+}
+
+func (o *Obfuscated2) Encrypt(data []byte) []byte {
+	buf := make([]byte, len(data))
+	o.encryptor.XORKeyStream(buf, data)
+	return buf
+}
+
+func (o *Obfuscated2) Decrypt(data []byte) []byte {
+	buf := make([]byte, len(data))
+	o.decryptor.XORKeyStream(buf, data)
+	return buf
+}
+
+func ParseObfuscated2ClientFrame(secret, data []byte) (*Obfuscated2, int16, error) {
+	frame := Frame(data)
+
+	decHasher := sha256.New()
+	decHasher.Write(frame.Key())
+	decHasher.Write(secret)
+	decryptor := makeStreamCipher(decHasher.Sum(nil), frame.IV())
+
+	invertedFrame := frame.Invert()
+	encHasher := sha256.New()
+	encHasher.Write(invertedFrame.Key())
+	encHasher.Write(secret)
+	encryptor := makeStreamCipher(encHasher.Sum(nil), invertedFrame.IV())
+
+	decryptedFrame := make(Frame, FrameLen)
+	decryptor.XORKeyStream(decryptedFrame, frame)
+	if !decryptedFrame.Valid() {
+		return nil, 0, errors.New("Unknown protocol")
+	}
+
+	obfs := &Obfuscated2{
+		decryptor: decryptor,
+		encryptor: encryptor,
+	}
+
+	return obfs, decryptedFrame.DC(), nil
+}
+
+func MakeTelegramObfuscated2Frame() (*Obfuscated2, Frame) {
+	frame := generateFrame()
+
+	encryptor := makeStreamCipher(frame.Key(), frame.IV())
+	decryptorFrame := frame.Invert()
+	decryptor := makeStreamCipher(decryptorFrame.Key(), decryptorFrame.IV())
+
+	copyFrame := make(Frame, frameOffsetIV)
+	copy(copyFrame, frame)
+	encryptor.XORKeyStream(frame, frame)
+	copy(frame, copyFrame)
+
+	obfs := &Obfuscated2{
+		decryptor: decryptor,
+		encryptor: encryptor,
+	}
+
+	return obfs, frame
+}
+
+func makeStreamCipher(key, iv []byte) cipher.Stream {
+	block, _ := aes.NewCipher(key)
+	return cipher.NewCTR(block, iv)
+}

obfuscated2/obfuscated2_test.go

@@ -0,0 +1,79 @@
+package obfuscated2
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestObfs2TelegramFrameDecrypt(t *testing.T) {
+	_, frame := MakeTelegramObfuscated2Frame()
+	decryptor := makeStreamCipher(frame.Key(), frame.IV())
+
+	decrypted := make(Frame, FrameLen)
+	decryptor.XORKeyStream(decrypted, frame)
+
+	assert.True(t, decrypted.Valid())
+}
+
+func TestObfs2TelegramDecryptEncryptDecrypt(t *testing.T) {
+	obfs2, frame := MakeTelegramObfuscated2Frame()
+	inverted := frame.Invert()
+	encryptor := makeStreamCipher(inverted.Key(), inverted.IV())
+
+	data := []byte{1, 2, 3}
+	encrypted := make([]byte, 3)
+	encryptor.XORKeyStream(encrypted, data)
+	decrypted := obfs2.Decrypt(encrypted)
+
+	assert.Equal(t, data, decrypted)
+}
+
+func TestObfs2Full(t *testing.T) {
+	secret := []byte{1, 2, 3, 4, 5}
+
+	clientFrame := generateFrame()
+	clientHasher := sha256.New()
+	clientHasher.Write(clientFrame.Key())
+	clientHasher.Write(secret)
+	clientKey := clientHasher.Sum(nil)
+
+	encryptor := makeStreamCipher(clientKey, clientFrame.IV())
+	encrypted := make(Frame, FrameLen)
+	encryptor.XORKeyStream(encrypted, clientFrame)
+	copy(encrypted[:56], clientFrame[:56])
+
+	invertedClientFrame := clientFrame.Invert()
+	clientHasher = sha256.New()
+	clientHasher.Write(invertedClientFrame.Key())
+	clientHasher.Write(secret)
+	invertedClientKey := clientHasher.Sum(nil)
+	clientDecryptor := makeStreamCipher(invertedClientKey, invertedClientFrame.IV())
+
+	clientObfs, _, err := ParseObfuscated2ClientFrame(secret, encrypted)
+	assert.Nil(t, err)
+
+	tgObfs, tgFrame := MakeTelegramObfuscated2Frame()
+	tgDecryptor := makeStreamCipher(tgFrame.Key(), tgFrame.IV())
+	decrypted := make(Frame, FrameLen)
+	tgDecryptor.XORKeyStream(decrypted, tgFrame)
+	assert.True(t, decrypted.Valid())
+
+	tgInvertedFrame := tgFrame.Invert()
+	tgEncryptor := makeStreamCipher(tgInvertedFrame.Key(), tgInvertedFrame.IV())
+
+	message := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	tgEncryptedMessage := make([]byte, len(message))
+	tgEncryptor.XORKeyStream(tgEncryptedMessage, message)
+
+	tgEncDecryptedMessage := tgObfs.Decrypt(tgEncryptedMessage)
+	assert.Equal(t, message, tgEncDecryptedMessage)
+
+	clientEncryptedMessage := clientObfs.Encrypt(tgEncDecryptedMessage)
+	finalMessage := make([]byte, len(clientEncryptedMessage))
+	clientDecryptor.XORKeyStream(finalMessage, clientEncryptedMessage)
+
+	assert.Equal(t, finalMessage, message)
+}