Fix android ping

mtglib/internal/tls/fake/server_side.go

 	0x00, 0x20, // 32 bytes of key
 }
 
-func SendServerHello(w io.Writer, secret []byte, clientHello *ClientHello) ([]byte, error) {
+func SendServerHello(w io.Writer, secret []byte, clientHello *ClientHello) error {
 	buf := &bytes.Buffer{}
 	buf.Grow(tls.MaxRecordSize)
 
 	generateServerHello(buf, clientHello)
 	generateChangeCipherValue(buf)
-
-	noise := &bytes.Buffer{}
-	generateNoise(noise)
+	generateNoise(buf)
 
 	packet := buf.Bytes()
 	digest := hmac.New(sha256.New, secret)
 
 	digest.Write(clientHello.Random[:])
 	digest.Write(packet)
-	digest.Write(noise.Bytes())
 	copy(packet[RandomOffset:], digest.Sum(nil))
 
 	_, err := w.Write(packet)
 
-	return noise.Bytes()[tls.SizeHeader:], err
+	return err
 }
 
 func generateServerHello(buf *bytes.Buffer, hello *ClientHello) {

mtglib/internal/tls/fake/server_side_test.go

 }
 
 func (suite *SendServerHelloTestSuite) TestRecordStructure() {
-	noise, err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
+	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
 	suite.NoError(err)
 
 	var rec bytes.Buffer
 	suite.NoError(err)
 	suite.Equal(byte(tls.TypeChangeCipherSpec), recordType)
 
-	suite.Empty(suite.buf.Bytes())
+	rec.Reset()
 
-	// noise is raw payload without TLS record header
-	suite.Len(noise, 1369)
+	recordType, length, err := tls.ReadRecord(suite.buf, &rec)
+	suite.NoError(err)
+	suite.Equal(byte(tls.TypeApplicationData), recordType)
+	suite.Equal(int64(1369), length)
+
+	suite.Empty(suite.buf.Bytes())
 }
 
 func (suite *SendServerHelloTestSuite) TestHMAC() {
-	noise, err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
+	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
 	suite.NoError(err)
 
 	packet := make([]byte, suite.buf.Len())
 	mac.Write(suite.hello.Random[:])
 	mac.Write(packet)
 
-	// HMAC is computed over the full noise TLS record (with header),
-	// but SendServerHello returns noise without the header,
-	// so we reconstruct the full record.
-	var fullNoise bytes.Buffer
-	tls.WriteRecord(&fullNoise, noise) //nolint: errcheck
-	mac.Write(fullNoise.Bytes())
-
 	suite.Equal(random, mac.Sum(nil))
 }
 
 func (suite *SendServerHelloTestSuite) TestHandshakePayload() {
-	_, err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
+	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
 	suite.NoError(err)
 
 	packet := suite.buf.Bytes()
 }
 
 func (suite *SendServerHelloTestSuite) TestChangeCipherSpec() {
-	_, err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
+	err := fake.SendServerHello(suite.buf, suite.secret.Key[:], suite.hello)
 	suite.NoError(err)
 
 	// Skip first record

mtglib/proxy.go

 		ctx.logger.Info("Stream has been finished")
 	}()
 
-	noise, ok := p.doFakeTLSHandshake(ctx)
-	if !ok {
+	if !p.doFakeTLSHandshake(ctx) {
 		return
 	}
 
 	}
 	defer clientConn.Stop()
 
-	if _, err := clientConn.SyncWrite(noise); err != nil {
-		ctx.logger.InfoError("cannot send the first packet", err)
-		return
-	}
-
 	ctx.clientConn = clientConn
 
 	if err := p.doObfuscatedHandshake(ctx); err != nil {
 	p.blocklist.Shutdown()
 }
 
-func (p *Proxy) doFakeTLSHandshake(ctx *streamContext) ([]byte, bool) {
+func (p *Proxy) doFakeTLSHandshake(ctx *streamContext) bool {
 	rewind := newConnRewind(ctx.clientConn)
 
 	clientHello, err := fake.ReadClientHello(
 	if err != nil {
 		p.logger.InfoError("cannot read client hello", err)
 		p.doDomainFronting(ctx, rewind)
-		return nil, false
+		return false
 	}
 
 	if p.antiReplayCache.SeenBefore(clientHello.SessionID) {
 		p.logger.Warning("replay attack has been detected!")
 		p.eventStream.Send(p.ctx, NewEventReplayAttack(ctx.streamID))
 		p.doDomainFronting(ctx, rewind)
-		return nil, false
+		return false
 	}
 
-	noise, err := fake.SendServerHello(ctx.clientConn, p.secret.Key[:], clientHello)
-	if err != nil {
+	if err := fake.SendServerHello(ctx.clientConn, p.secret.Key[:], clientHello); err != nil {
 		p.logger.InfoError("cannot send welcome packet", err)
-		return nil, false
+		return false
 	}
 
 	ctx.clientConn = tls.New(ctx.clientConn, true, false)
 
-	return noise, true
+	return true
 }
 
 func (p *Proxy) doObfuscatedHandshake(ctx *streamContext) error {