adjust API

Author: noboruma

conn.go

@@ -726,14 +726,13 @@ func (c *Conn) processHandshakePacket(pkt *packet, dtlsHandshake *handshake.Hand
 				SequenceNumber: pkt.record.Header.SequenceNumber,
 			}
 
-			hs := recordlayer.FixedHeaderSize + len(cidHeader.ConnectionID)
-			rawPacket = make([]byte, hs+len(rawInner))
-			err = cidHeader.MarshalInto(rawPacket)
+			rawPacket = make([]byte, cidHeader.MarshalSize()+len(rawInner))
+			_, err = cidHeader.MarshalTo(rawPacket)
 			if err != nil {
 				return nil, err
 			}
 			pkt.record.Header = *cidHeader
-			copy(rawPacket[hs:], rawInner)
+			copy(rawPacket[cidHeader.MarshalSize():], rawInner)
 		} else {
 			recordlayerHeader := &recordlayer.Header{
 				Version:        pkt.record.Header.Version,
@@ -743,15 +742,14 @@ func (c *Conn) processHandshakePacket(pkt *packet, dtlsHandshake *handshake.Hand
 				SequenceNumber: seq,
 			}
 
-			hs := recordlayer.FixedHeaderSize + len(recordlayerHeader.ConnectionID)
-			rawPacket = make([]byte, hs+len(handshakeFragment))
-			err = recordlayerHeader.MarshalInto(rawPacket)
+			rawPacket = make([]byte, recordlayerHeader.MarshalSize()+len(handshakeFragment))
+			_, err = recordlayerHeader.MarshalTo(rawPacket)
 			if err != nil {
 				return nil, err
 			}
 
 			pkt.record.Header = *recordlayerHeader
-			copy(rawPacket[hs:], handshakeFragment)
+			copy(rawPacket[recordlayerHeader.MarshalSize():], handshakeFragment)
 		}
 
 		if pkt.shouldEncrypt {
@@ -797,7 +795,7 @@ func (c *Conn) fragmentHandshake(dtlsHandshake *handshake.Handshake) ([][]byte,
 		offset += contentFragmentLen
 
 		fragmentedHandshake := make([]byte, handshake.HeaderLength+len(contentFragment))
-		err := headerFragment.MarshalInto(fragmentedHandshake)
+		_, err := headerFragment.MarshalTo(fragmentedHandshake)
 		if err != nil {
 			return nil, err
 		}
@@ -1011,7 +1009,7 @@ func (c *Conn) handleIncomingPacket(
 		if header.ContentType == protocol.ContentTypeConnectionID {
 			originalCID = true
 			ip := &recordlayer.InnerPlaintext{}
-			if err := ip.Unmarshal(buf[header.Size():]); err != nil { //nolint:govet
+			if err := ip.Unmarshal(buf[header.MarshalSize():]); err != nil { //nolint:govet
 				c.log.Debugf("unpacking inner plaintext failed: %s", err)
 
 				return false, false, nil, nil

pkg/crypto/ciphersuite/cbc.go

@@ -68,8 +68,8 @@ func NewCBC(
 
 // Encrypt encrypt a DTLS RecordLayer message.
 func (c *CBC) Encrypt(pkt *recordlayer.RecordLayer, raw []byte) ([]byte, error) {
-	payload := raw[pkt.Header.Size():]
-	raw = raw[:pkt.Header.Size()]
+	payload := raw[pkt.Header.MarshalSize():]
+	raw = raw[:pkt.Header.MarshalSize()]
 	blockSize := c.writeCBC.BlockSize()
 
 	// Generate + Append MAC
@@ -110,7 +110,7 @@ func (c *CBC) Encrypt(pkt *recordlayer.RecordLayer, raw []byte) ([]byte, error)
 	raw = append(raw, payload...)
 
 	// Update recordLayer size to include IV+MAC+Padding
-	binary.BigEndian.PutUint16(raw[pkt.Header.Size()-2:], uint16(len(raw)-pkt.Header.Size())) //nolint:gosec //G115
+	binary.BigEndian.PutUint16(raw[pkt.Header.MarshalSize()-2:], uint16(len(raw)-pkt.Header.MarshalSize())) //nolint:gosec //G115
 
 	return raw, nil
 }
@@ -123,7 +123,7 @@ func (c *CBC) Decrypt(header recordlayer.Header, in []byte) ([]byte, error) {
 	if err := header.Unmarshal(in); err != nil {
 		return nil, err
 	}
-	body := in[header.Size():]
+	body := in[header.MarshalSize():]
 
 	switch {
 	case header.ContentType == protocol.ContentTypeChangeCipherSpec:
@@ -171,7 +171,7 @@ func (c *CBC) Decrypt(header recordlayer.Header, in []byte) ([]byte, error) {
 		return nil, errInvalidMAC
 	}
 
-	return append(in[:header.Size()], body[:dataEnd]...), nil
+	return append(in[:header.MarshalSize()], body[:dataEnd]...), nil
 }
 
 func (c *CBC) hmac(

pkg/crypto/ciphersuite/chacha20poly1305.go

@@ -51,8 +51,8 @@ func NewChaCha20Poly1305(localKey, localWriteIV, remoteKey, remoteWriteIV []byte
 
 // Encrypt encrypts a DTLS RecordLayer message.
 func (c *ChaCha20Poly1305) Encrypt(pkt *recordlayer.RecordLayer, raw []byte) ([]byte, error) {
-	payload := raw[pkt.Header.Size():]
-	raw = raw[:pkt.Header.Size()]
+	payload := raw[pkt.Header.MarshalSize():]
+	raw = raw[:pkt.Header.MarshalSize()]
 
 	var nonce [chachaNonceLength]byte
 	copy(nonce[:], c.localWriteIV)
@@ -80,7 +80,7 @@ func (c *ChaCha20Poly1305) Encrypt(pkt *recordlayer.RecordLayer, raw []byte) ([]
 	copy(result, raw)
 	copy(result[len(raw):], encrypted)
 
-	binary.BigEndian.PutUint16(result[pkt.Header.Size()-2:], uint16(len(encrypted))) //nolint:gosec
+	binary.BigEndian.PutUint16(result[pkt.Header.MarshalSize()-2:], uint16(len(encrypted))) //nolint:gosec
 
 	return result, nil
 }
@@ -108,7 +108,7 @@ func (c *ChaCha20Poly1305) Decrypt(header recordlayer.Header, in []byte) ([]byte
 	}
 
 	// NOTE: ChaCha20-Poly1305 has NO explicit nonce in the record
-	ciphertext := in[header.Size():]
+	ciphertext := in[header.MarshalSize():]
 
 	var additionalData []byte
 	if header.ContentType == protocol.ContentTypeConnectionID {
@@ -122,5 +122,5 @@ func (c *ChaCha20Poly1305) Decrypt(header recordlayer.Header, in []byte) ([]byte
 		return nil, fmt.Errorf("%w: %v", errDecryptPacket, err) //nolint:errorlint
 	}
 
-	return append(in[:header.Size()], plaintext...), nil
+	return append(in[:header.MarshalSize()], plaintext...), nil
 }

pkg/crypto/ciphersuite/ciphersuite.go

@@ -73,8 +73,8 @@ func newAEAD(
 
 // encrypt encrypts a DTLS RecordLayer message.
 func (a *aead) encrypt(pkt *recordlayer.RecordLayer, raw []byte) ([]byte, error) {
-	payload := raw[pkt.Header.Size():]
-	raw = raw[:pkt.Header.Size()]
+	payload := raw[pkt.Header.MarshalSize():]
+	raw = raw[:pkt.Header.MarshalSize()]
 
 	// Get nonce buffer from pool
 	noncePtr := a.nonceBufferPool.Get().(*[]byte) // nolint:forcetypeassert
@@ -100,7 +100,7 @@ func (a *aead) encrypt(pkt *recordlayer.RecordLayer, raw []byte) ([]byte, error)
 	a.localAEAD.Seal(r[len(raw)+8:len(raw)+8], nonce, payload, additionalData)
 
 	// Update recordLayer size to include explicit nonce
-	binary.BigEndian.PutUint16(r[pkt.Header.Size()-2:], uint16(len(r)-pkt.Header.Size())) //nolint:gosec //G115
+	binary.BigEndian.PutUint16(r[pkt.Header.MarshalSize()-2:], uint16(len(r)-pkt.Header.MarshalSize())) //nolint:gosec //G115
 
 	// Return nonce buffer to pool
 	a.nonceBufferPool.Put(noncePtr)
@@ -117,7 +117,7 @@ func (a *aead) decrypt(header recordlayer.Header, in []byte) ([]byte, error) {
 	case header.ContentType == protocol.ContentTypeChangeCipherSpec:
 		// Nothing to encrypt with ChangeCipherSpec
 		return in, nil
-	case len(in) <= (8 + header.Size()):
+	case len(in) <= (8 + header.MarshalSize()):
 		return nil, errNotEnoughRoomForNonce
 	}
 
@@ -126,8 +126,8 @@ func (a *aead) decrypt(header recordlayer.Header, in []byte) ([]byte, error) {
 	nonce := *noncePtr
 
 	copy(nonce[:4], a.remoteWriteIV[:4])
-	copy(nonce[4:], in[header.Size():header.Size()+8])
-	out := in[header.Size()+8:]
+	copy(nonce[4:], in[header.MarshalSize():header.MarshalSize()+8])
+	out := in[header.MarshalSize()+8:]
 
 	var additionalData []byte
 	if header.ContentType == protocol.ContentTypeConnectionID {
@@ -146,7 +146,7 @@ func (a *aead) decrypt(header recordlayer.Header, in []byte) ([]byte, error) {
 	// Return nonce buffer to pool
 	a.nonceBufferPool.Put(noncePtr)
 
-	return append(in[:header.Size()], out...), nil
+	return append(in[:header.MarshalSize()], out...), nil
 }
 
 func generateAEADAdditionalData(h *recordlayer.Header, payloadLen int) []byte {

pkg/protocol/alert/alert.go

@@ -145,28 +145,28 @@ func (a Alert) ContentType() protocol.ContentType {
 	return protocol.ContentTypeAlert
 }
 
-// Size returns the minimal buffer size required for MarshalInto.
-func (a Alert) Size() int {
+// MarshalSize returns the minimal buffer size required for MarshalTo.
+func (a Alert) MarshalSize() int {
 	return 2
 }
 
 // Marshal returns the encoded alert.
 func (a *Alert) Marshal() ([]byte, error) {
-	out := make([]byte, a.Size())
-	err := a.MarshalInto(out)
+	out := make([]byte, a.MarshalSize())
+	_, err := a.MarshalTo(out)
 
 	return out, err
 }
 
-// MarshalInto returns the encoded alert.
-func (a *Alert) MarshalInto(out []byte) error {
-	if len(out) < a.Size() {
-		return errBufferTooSmall
+// MarshalTo returns the encoded alert.
+func (a *Alert) MarshalTo(out []byte) (int, error) {
+	if len(out) < a.MarshalSize() {
+		return 0, errBufferTooSmall
 	}
 	out[0] = byte(a.Level)
 	out[1] = byte(a.Description)
 
-	return nil
+	return 2, nil
 }
 
 // Unmarshal populates the alert from binary data.

pkg/protocol/application_data.go

@@ -20,20 +20,20 @@ func (a ApplicationData) ContentType() ContentType {
 // Marshal encodes the ApplicationData to binary.
 func (a *ApplicationData) Marshal() ([]byte, error) {
 	out := make([]byte, len(a.Data))
-	err := a.MarshalInto(out)
+	_, err := a.MarshalTo(out)
 
 	return out, err
 }
 
-// MarshalInto encodes the ApplicationData to binary into a pre-allocated buffer.
-func (a *ApplicationData) MarshalInto(out []byte) error {
+// MarshalTo encodes the ApplicationData to binary into a pre-allocated buffer.
+func (a *ApplicationData) MarshalTo(out []byte) (int, error) {
 	copy(out, a.Data)
 
-	return nil
+	return len(a.Data), nil
 }
 
-// Size returns the size required for MarshalInto.
-func (a ApplicationData) Size() int {
+// MarshalSize returns the size required for MarshalTo.
+func (a ApplicationData) MarshalSize() int {
 	return len(a.Data)
 }
 

pkg/protocol/change_cipher_spec.go

@@ -15,27 +15,27 @@ func (c ChangeCipherSpec) ContentType() ContentType {
 	return ContentTypeChangeCipherSpec
 }
 
-// Size returns the minimal buffer size required for MarshalInto.
-func (c ChangeCipherSpec) Size() int {
+// MarshalSize returns the minimal buffer size required for MarshalTo.
+func (c ChangeCipherSpec) MarshalSize() int {
 	return 1
 }
 
 // Marshal encodes the ChangeCipherSpec to binary.
 func (c *ChangeCipherSpec) Marshal() ([]byte, error) {
 	out := make([]byte, 1)
-	err := c.MarshalInto(out)
+	_, err := c.MarshalTo(out)
 
 	return out, err
 }
 
-// MarshalInto encodes the ChangeCipherSpec to binary into a pre-allocated buffer.
-func (c *ChangeCipherSpec) MarshalInto(out []byte) error {
-	if len(out) < c.Size() {
-		return errBufferTooSmall
+// MarshalTo encodes the ChangeCipherSpec to binary into a pre-allocated buffer.
+func (c *ChangeCipherSpec) MarshalTo(out []byte) (int, error) {
+	if len(out) < c.MarshalSize() {
+		return 0, errBufferTooSmall
 	}
 	out[0] = 0x01
 
-	return nil
+	return 1, nil
 }
 
 // Unmarshal populates the ChangeCipherSpec from binary.

pkg/protocol/content.go

@@ -21,7 +21,7 @@ const (
 type Content interface {
 	ContentType() ContentType
 	Marshal() ([]byte, error)
-	MarshalInto([]byte) error
+	MarshalTo([]byte) (int, error)
 	Unmarshal(data []byte) error
-	Size() int
+	MarshalSize() int
 }

pkg/protocol/handshake/handshake.go

@@ -62,8 +62,8 @@ func (t Type) String() string { //nolint:cyclop
 // Message is the body of a Handshake datagram.
 type Message interface {
 	Marshal() ([]byte, error)
-	MarshalInto([]byte) error
-	Size() int
+	MarshalTo([]byte) (int, error)
+	MarshalSize() int
 	Unmarshal(data []byte) error
 	Type() Type
 }
@@ -86,9 +86,9 @@ func (h Handshake) ContentType() protocol.ContentType {
 	return protocol.ContentTypeHandshake
 }
 
-// Size returns the minimal buffer size required for MarshalInto.
-func (h *Handshake) Size() int {
-	return HeaderLength + h.Message.Size()
+// MarshalSize returns the minimal buffer size required for MarshalTo.
+func (h *Handshake) MarshalSize() int {
+	return HeaderLength + h.Message.MarshalSize()
 }
 
 // Marshal encodes a handshake into a binary message.
@@ -98,38 +98,38 @@ func (h *Handshake) Marshal() ([]byte, error) {
 	} else if h.Header.FragmentOffset != 0 {
 		return nil, errUnableToMarshalFragmented
 	}
-	out := make([]byte, h.Size())
-	err := h.MarshalInto(out)
+	out := make([]byte, h.MarshalSize())
+	_, err := h.MarshalTo(out)
 
 	return out, err
 }
 
-// MarshalInto encodes a handshake into a binary message into a pre-allocated buffer.
-func (h *Handshake) MarshalInto(out []byte) error {
+// MarshalTo encodes a handshake into a binary message into a pre-allocated buffer.
+func (h *Handshake) MarshalTo(out []byte) (int, error) {
 	if h.Message == nil {
-		return errHandshakeMessageUnset
+		return 0, errHandshakeMessageUnset
 	} else if h.Header.FragmentOffset != 0 {
-		return errUnableToMarshalFragmented
+		return 0, errUnableToMarshalFragmented
 	}
 
-	if len(out) < h.Size() {
-		return errBufferTooSmall
+	if len(out) < h.MarshalSize() {
+		return 0, errBufferTooSmall
 	}
 
-	h.Header.Length = uint32(h.Message.Size()) //nolint:gosec // G115
+	h.Header.Length = uint32(h.Message.MarshalSize()) //nolint:gosec // G115
 	h.Header.FragmentLength = h.Header.Length
 	h.Header.Type = h.Message.Type()
-	err := h.Header.MarshalInto(out)
+	_, err := h.Header.MarshalTo(out)
 	if err != nil {
-		return err
+		return 0, err
 	}
 
-	err = h.Message.MarshalInto(out[HeaderLength:])
+	_, err = h.Message.MarshalTo(out[HeaderLength:])
 	if err != nil {
-		return err
+		return 0, err
 	}
 
-	return nil
+	return h.MarshalSize(), nil
 }
 
 // Unmarshal decodes a handshake from a binary message.

pkg/protocol/handshake/header.go

@@ -29,15 +29,15 @@ type Header struct {
 // Marshal encodes the Header.
 func (h *Header) Marshal() ([]byte, error) {
 	out := make([]byte, HeaderLength)
-	err := h.MarshalInto(out)
+	_, err := h.MarshalTo(out)
 
 	return out, err
 }
 
-// MarshalInto encodes the Header using a pre-allocated buffer.
-func (h *Header) MarshalInto(out []byte) error {
+// MarshalTo encodes the Header using a pre-allocated buffer.
+func (h *Header) MarshalTo(out []byte) (int, error) {
 	if len(out) < HeaderLength {
-		return errBufferTooSmall
+		return 0, errBufferTooSmall
 	}
 
 	out[0] = byte(h.Type)
@@ -46,7 +46,7 @@ func (h *Header) MarshalInto(out []byte) error {
 	util.PutBigEndianUint24(out[6:], h.FragmentOffset)
 	util.PutBigEndianUint24(out[9:], h.FragmentLength)
 
-	return nil
+	return HeaderLength, nil
 }
 
 // Unmarshal populates the header from encoded data.