Fix lint issues

mtglib/internal/faketls/client_hello.go

 	// mac is calculated for the whole record, not only
 	// for the payload part
 	mac := hmac.New(sha256.New, secret)
-	rec.Dump(mac)
+	rec.Dump(mac) // nolint: errcheck
 
 	computedRandom := mac.Sum(nil)
 
 	hello.SessionID = make([]byte, handshake[ClientHelloSessionIDOffset])
 	copy(hello.SessionID, handshake[ClientHelloSessionIDOffset+1:])
 
-	cipherSuiteOffset := ClientHelloSessionIDOffset + 1 + len(hello.SessionID) + 2
+	cipherSuiteOffset := ClientHelloSessionIDOffset + len(hello.SessionID) + 3 // nolint: gomnd
 	hello.CipherSuite = binary.BigEndian.Uint16(handshake[cipherSuiteOffset : cipherSuiteOffset+2])
 
 	return hello, nil

mtglib/internal/faketls/init.go

 
 	HandshakeTypeClient = 0x01
 	HandshakeTypeServer = 0x02
+
+	ChangeCipherValue = 0x01
 )
 
 var (

mtglib/internal/faketls/pools.go

 }
 
 func acquireBytesBuffer() *bytes.Buffer {
-    return bytesBufferPool.Get().(*bytes.Buffer)
+	return bytesBufferPool.Get().(*bytes.Buffer)
 }
 
 func releaseBytesBuffer(b *bytes.Buffer) {
-    b.Reset()
-    bytesBufferPool.Put(b)
+	b.Reset()
+	bytesBufferPool.Put(b)
 }

mtglib/internal/faketls/welcome.go

 	rec.Version = record.Version12
 
 	generateServerHello(&rec.Payload, clientHello)
-	rec.Dump(buf)
+	rec.Dump(buf) // nolint: errcheck
 	rec.Reset()
 
 	rec.Type = record.TypeChangeCipherSpec
 	rec.Version = record.Version12
-	rec.Payload.WriteByte(0x01)
+	rec.Payload.WriteByte(ChangeCipherValue)
 
-	rec.Dump(buf)
+	rec.Dump(buf) // nolint: errcheck
 	rec.Reset()
 
 	rec.Type = record.TypeApplicationData
 	rec.Version = record.Version12
 
-	if _, err := io.CopyN(&rec.Payload, rand.Reader, int64(1024+mrand.Intn(3092))); err != nil {
+	if _, err := io.CopyN(&rec.Payload, rand.Reader, int64(1024+mrand.Intn(3092))); err != nil { // nolint: gomnd
 		panic(err)
 	}
 
-	rec.Dump(buf)
+	rec.Dump(buf) // nolint: errcheck
 
 	packet := buf.Bytes()
 	mac := hmac.New(sha256.New, secret)
 
-	mac.Write(clientHello.Random[:])
-	mac.Write(packet)
+	mac.Write(clientHello.Random[:]) // nolint: errcheck
+	mac.Write(packet)                // nolint: errcheck
 
 	copy(packet[WelcomePacketRandomOffset:], mac.Sum(nil))
 
 	bodyBuf.Write(serverHelloSuffix)
 
 	scalar := [32]byte{}
-	rand.Read(scalar[:])
+
+	if _, err := rand.Read(scalar[:]); err != nil {
+		panic(err)
+	}
+
 	curve, _ := curve25519.X25519(scalar[:], curve25519.Basepoint)
 	bodyBuf.Write(curve)
 
 	binary.BigEndian.PutUint32(header[:], uint32(bodyBuf.Len()))
 	header[0] = HandshakeTypeServer
 
-	writer.Write(header[:])
-	bodyBuf.WriteTo(writer)
+	writer.Write(header[:]) // nolint: errcheck
+	bodyBuf.WriteTo(writer) // nolint: errcheck
 }

mtglib/proxy.go

 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"net"
 	"sync"
 	"time"
 	p.workerPool.Release()
 }
 
-func (p *Proxy) doFakeTLSHandshake(ctx *streamContext, conn net.Conn) error {
+func (p *Proxy) doFakeTLSHandshake(ctx *streamContext, conn io.ReadWriter) error {
 	rec := record.AcquireRecord()
 	defer record.ReleaseRecord(rec)
 
 	return nil
 }
 
-func NewProxy(opts ProxyOpts) (*Proxy, error) { // nolint: cyclop
+func NewProxy(opts ProxyOpts) (*Proxy, error) { // nolint: cyclop, funlen
 	switch {
 	case opts.Network == nil:
 		return nil, ErrNetworkIsNotDefined