Unpool handshake

Anyway, we are going to use stack here, no need for connection pooling.
Even arrays are allocaed on a stack because we do not use slices here
but real ones.

mtglib/internal/obfuscated2/client_handshake.go

 package obfuscated2
 
 import (
+	"crypto/aes"
 	"crypto/cipher"
 	"crypto/subtle"
 	"encoding/hex"
 var clientHandshakeConnectionType = []byte{0xdd, 0xdd, 0xdd, 0xdd}
 
 func ClientHandshake(secret []byte, reader io.Reader) (int16, cipher.Stream, cipher.Stream, error) {
-	handshakeFrame := acquireHandshakeFrame()
-	defer releaseHandshakeFrame(handshakeFrame)
+	handshake := handshakeFrame{}
 
-	if _, err := io.ReadFull(reader, handshakeFrame.data[:]); err != nil {
+	if _, err := io.ReadFull(reader, handshake.data[:]); err != nil {
 		return 0, nil, nil, fmt.Errorf("cannot read frame: %w", err)
 	}
 
 	decHasher := acquireSha256Hasher()
 	defer releaseSha256Hasher(decHasher)
 
-	decHasher.Write(handshakeFrame.key()) // nolint: errcheck
-	decHasher.Write(secret)               // nolint: errcheck
-	decryptor := makeAesCtr(decHasher.Sum(nil), handshakeFrame.iv())
+	decHasher.Write(handshake.key()) // nolint: errcheck
+	decHasher.Write(secret)          // nolint: errcheck
+	decryptor := makeAesCtr(decHasher.Sum(nil), handshake.iv())
 
 	encHasher := acquireSha256Hasher()
 	defer releaseSha256Hasher(encHasher)
 
-	invertedFrame := acquireHandshakeFrame()
-	defer releaseHandshakeFrame(invertedFrame)
+	invertedHandshake := handshakeFrame{}
 
-	for i, v := range handshakeFrame.data {
-		invertedFrame.data[handshakeFrameLen-1-i] = v
+	for i, v := range handshake.data {
+		invertedHandshake.data[handshakeFrameLen-1-i] = v
 	}
 
-	encHasher.Write(invertedFrame.key()) // nolint: errcheck
-	encHasher.Write(secret)              // nolint: errcheck
-	encryptor := makeAesCtr(encHasher.Sum(nil), invertedFrame.iv())
+	encHasher.Write(invertedHandshake.key()) // nolint: errcheck
+	encHasher.Write(secret)                  // nolint: errcheck
+	encryptor := makeAesCtr(encHasher.Sum(nil), invertedHandshake.iv())
 
-	decryptor.XORKeyStream(handshakeFrame.data[:], handshakeFrame.data[:])
+	decryptor.XORKeyStream(handshake.data[:], handshake.data[:])
 
-	if val := handshakeFrame.connectionType(); subtle.ConstantTimeCompare(clientHandshakeConnectionType, val) != 1 {
+	if val := handshake.connectionType(); subtle.ConstantTimeCompare(clientHandshakeConnectionType, val) != 1 {
 		return 0, nil, nil, fmt.Errorf("unsupported connection type: %s", hex.EncodeToString(val))
 	}
 
-	return handshakeFrame.dc(), encryptor, decryptor, nil
+	return handshake.dc(), encryptor, decryptor, nil
 }
 
 func makeAesCtr(key, iv []byte) cipher.Stream {

mtglib/internal/obfuscated2/pools.go

 	"sync"
 )
 
-var (
-	sha256HasherPool = sync.Pool{
-		New: func() interface{} {
-			return sha256.New()
-		},
-	}
-	handshakeFramePool = sync.Pool{
-		New: func() interface{} {
-			return &handshakeFrame{}
-		},
-	}
-)
+var sha256HasherPool = sync.Pool{
+	New: func() interface{} {
+		return sha256.New()
+	},
+}
 
 func acquireSha256Hasher() hash.Hash {
 	return sha256HasherPool.Get().(hash.Hash)
 	h.Reset()
 	sha256HasherPool.Put(h)
 }
-
-func acquireHandshakeFrame() *handshakeFrame {
-	return handshakeFramePool.Get().(*handshakeFrame)
-}
-
-func releaseHandshakeFrame(h *handshakeFrame) {
-	handshakeFramePool.Put(h)
-}