Make ProtectionProfile methods public

sirzooro · sirzooro · commit e3e6d11b2184 · 2024-07-08T23:55:38.000+02:00
This allows to get values like key length and use them with key management protocols like MIKEY, instead of creating own constants for this. Resolves #258
diff --git a/context.go b/context.go
@@ -66,12 +66,12 @@ type Context struct {
 //
 //	decCtx, err := srtp.CreateContext(key, salt, profile, srtp.SRTPReplayProtection(256))
 func CreateContext(masterKey, masterSalt []byte, profile ProtectionProfile, opts ...ContextOption) (c *Context, err error) {
-	keyLen, err := profile.keyLen()
+	keyLen, err := profile.KeyLen()
 	if err != nil {
 		return nil, err
 	}
 
-	saltLen, err := profile.saltLen()
+	saltLen, err := profile.SaltLen()
 	if err != nil {
 		return nil, err
 	}
diff --git a/key_derivation_test.go b/key_derivation_test.go
@@ -32,7 +32,7 @@ func TestValidSessionKeys(t *testing.T) {
 		t.Errorf("Session Salt % 02x does not match expected % 02x", sessionSalt, expectedSessionSalt)
 	}
 
-	authKeyLen, err := ProtectionProfileAes128CmHmacSha1_80.authKeyLen()
+	authKeyLen, err := ProtectionProfileAes128CmHmacSha1_80.AuthKeyLen()
 	assert.NoError(t, err)
 
 	sessionAuthTag, err := aesCmKeyDerivation(labelSRTPAuthenticationTag, masterKey, masterSalt, 0, authKeyLen)
diff --git a/keying.go b/keying.go
@@ -14,12 +14,12 @@ type KeyingMaterialExporter interface {
 // extracting them from DTLS. This behavior is defined in RFC5764:
 // https://tools.ietf.org/html/rfc5764
 func (c *Config) ExtractSessionKeysFromDTLS(exporter KeyingMaterialExporter, isClient bool) error {
-	keyLen, err := c.Profile.keyLen()
+	keyLen, err := c.Profile.KeyLen()
 	if err != nil {
 		return err
 	}
 
-	saltLen, err := c.Profile.saltLen()
+	saltLen, err := c.Profile.SaltLen()
 	if err != nil {
 		return err
 	}
diff --git a/protection_profile.go b/protection_profile.go
@@ -17,7 +17,8 @@ const (
 	ProtectionProfileAeadAes256Gcm       ProtectionProfile = 0x0008
 )
 
-func (p ProtectionProfile) keyLen() (int, error) {
+// KeyLen returns length of encryption key in bytes.
+func (p ProtectionProfile) KeyLen() (int, error) {
 	switch p {
 	case ProtectionProfileAes128CmHmacSha1_32, ProtectionProfileAes128CmHmacSha1_80, ProtectionProfileAeadAes128Gcm:
 		return 16, nil
@@ -28,7 +29,8 @@ func (p ProtectionProfile) keyLen() (int, error) {
 	}
 }
 
-func (p ProtectionProfile) saltLen() (int, error) {
+// SaltLen returns length of salt key in bytes.
+func (p ProtectionProfile) SaltLen() (int, error) {
 	switch p {
 	case ProtectionProfileAes128CmHmacSha1_32, ProtectionProfileAes128CmHmacSha1_80:
 		return 14, nil
@@ -39,7 +41,8 @@ func (p ProtectionProfile) saltLen() (int, error) {
 	}
 }
 
-func (p ProtectionProfile) rtpAuthTagLen() (int, error) {
+// AuthTagRTPLen returns length of RTP authentication tag in bytes for AES protection profiles. For AEAD ones it returns zero.
+func (p ProtectionProfile) AuthTagRTPLen() (int, error) {
 	switch p {
 	case ProtectionProfileAes128CmHmacSha1_80:
 		return 10, nil
@@ -52,7 +55,8 @@ func (p ProtectionProfile) rtpAuthTagLen() (int, error) {
 	}
 }
 
-func (p ProtectionProfile) rtcpAuthTagLen() (int, error) {
+// AuthTagRTCPLen returns length of RTCP authentication tag in bytes for AES protection profiles. For AEAD ones it returns zero.
+func (p ProtectionProfile) AuthTagRTCPLen() (int, error) {
 	switch p {
 	case ProtectionProfileAes128CmHmacSha1_32, ProtectionProfileAes128CmHmacSha1_80:
 		return 10, nil
@@ -63,7 +67,8 @@ func (p ProtectionProfile) rtcpAuthTagLen() (int, error) {
 	}
 }
 
-func (p ProtectionProfile) aeadAuthTagLen() (int, error) {
+// AEADAuthTagLen returns length of authentication tag in bytes for AEAD protection profiles. For AES ones it returns zero.
+func (p ProtectionProfile) AEADAuthTagLen() (int, error) {
 	switch p {
 	case ProtectionProfileAes128CmHmacSha1_32, ProtectionProfileAes128CmHmacSha1_80:
 		return 0, nil
@@ -74,7 +79,8 @@ func (p ProtectionProfile) aeadAuthTagLen() (int, error) {
 	}
 }
 
-func (p ProtectionProfile) authKeyLen() (int, error) {
+// AuthKeyLen returns length of authentication key in bytes for AES protection profiles. For AEAD ones it returns zero.
+func (p ProtectionProfile) AuthKeyLen() (int, error) {
 	switch p {
 	case ProtectionProfileAes128CmHmacSha1_32, ProtectionProfileAes128CmHmacSha1_80:
 		return 20, nil
@@ -85,6 +91,7 @@ func (p ProtectionProfile) authKeyLen() (int, error) {
 	}
 }
 
+// String returns the name of the protection profile.
 func (p ProtectionProfile) String() string {
 	switch p {
 	case ProtectionProfileAes128CmHmacSha1_80:
diff --git a/protection_profile_test.go b/protection_profile_test.go
@@ -12,9 +12,9 @@ import (
 func TestInvalidProtectionProfile(t *testing.T) {
 	var invalidProtectionProfile ProtectionProfile
 
-	_, err := invalidProtectionProfile.keyLen()
+	_, err := invalidProtectionProfile.KeyLen()
 	assert.Error(t, err)
 
-	_, err = invalidProtectionProfile.saltLen()
+	_, err = invalidProtectionProfile.SaltLen()
 	assert.Error(t, err)
 }
diff --git a/session_srtcp_test.go b/session_srtcp_test.go
@@ -341,7 +341,7 @@ func TestSessionSRTCPAcceptStreamTimeout(t *testing.T) {
 }
 
 func getSenderSSRC(t *testing.T, stream *ReadStreamSRTCP) (ssrc uint32, err error) {
-	authTagSize, err := ProtectionProfileAes128CmHmacSha1_80.rtcpAuthTagLen()
+	authTagSize, err := ProtectionProfileAes128CmHmacSha1_80.AuthTagRTCPLen()
 	if err != nil {
 		return 0, err
 	}
diff --git a/srtcp.go b/srtcp.go
@@ -15,11 +15,11 @@ const maxSRTCPIndex = 0x7FFFFFFF
 func (c *Context) decryptRTCP(dst, encrypted []byte) ([]byte, error) {
 	out := allocateIfMismatch(dst, encrypted)
 
-	authTagLen, err := c.cipher.rtcpAuthTagLen()
+	authTagLen, err := c.cipher.AuthTagRTCPLen()
 	if err != nil {
 		return nil, err
 	}
-	aeadAuthTagLen, err := c.cipher.aeadAuthTagLen()
+	aeadAuthTagLen, err := c.cipher.AEADAuthTagLen()
 	if err != nil {
 		return nil, err
 	}
diff --git a/srtcp_test.go b/srtcp_test.go
@@ -164,10 +164,10 @@ func TestRTCPLifecycleInPlace(t *testing.T) {
 		testCase := testCase
 		t.Run(caseName, func(t *testing.T) {
 			assert := assert.New(t)
-			authTagLen, err := testCase.algo.rtcpAuthTagLen()
+			authTagLen, err := testCase.algo.AuthTagRTCPLen()
 			assert.NoError(err)
 
-			aeadAuthTagLen, err := testCase.algo.aeadAuthTagLen()
+			aeadAuthTagLen, err := testCase.algo.AEADAuthTagLen()
 			assert.NoError(err)
 
 			encryptHeader := &rtcp.Header{}
@@ -272,10 +272,10 @@ func TestRTCPInvalidAuthTag(t *testing.T) {
 		testCase := testCase
 		t.Run(caseName, func(t *testing.T) {
 			assert := assert.New(t)
-			authTagLen, err := testCase.algo.rtcpAuthTagLen()
+			authTagLen, err := testCase.algo.AuthTagRTCPLen()
 			assert.NoError(err)
 
-			aeadAuthTagLen, err := testCase.algo.aeadAuthTagLen()
+			aeadAuthTagLen, err := testCase.algo.AEADAuthTagLen()
 			assert.NoError(err)
 
 			decryptContext, err := CreateContext(testCase.masterKey, testCase.masterSalt, testCase.algo)
@@ -354,7 +354,7 @@ func TestEncryptRTCPSeparation(t *testing.T) {
 			encryptContext, err := CreateContext(testCase.masterKey, testCase.masterSalt, testCase.algo)
 			assert.NoError(err)
 
-			authTagLen, err := testCase.algo.rtcpAuthTagLen()
+			authTagLen, err := testCase.algo.AuthTagRTCPLen()
 			assert.NoError(err)
 
 			decryptContext, err := CreateContext(
diff --git a/srtp.go b/srtp.go
@@ -9,7 +9,7 @@ import (
 )
 
 func (c *Context) decryptRTP(dst, ciphertext []byte, header *rtp.Header, headerLen int) ([]byte, error) {
-	authTagLen, err := c.cipher.rtpAuthTagLen()
+	authTagLen, err := c.cipher.AuthTagRTPLen()
 	if err != nil {
 		return nil, err
 	}
diff --git a/srtp_cipher.go b/srtp_cipher.go
@@ -8,13 +8,13 @@ import "github.com/pion/rtp"
 // cipher represents a implementation of one
 // of the SRTP Specific ciphers
 type srtpCipher interface {
-	// authTagLen returns auth key length of the cipher.
+	// AuthTagRTPLen/AuthTagRTCPLen return auth key length of the cipher.
 	// See the note below.
-	rtpAuthTagLen() (int, error)
-	rtcpAuthTagLen() (int, error)
-	// aeadAuthTagLen returns AEAD auth key length of the cipher.
+	AuthTagRTPLen() (int, error)
+	AuthTagRTCPLen() (int, error)
+	// AEADAuthTagLen returns AEAD auth key length of the cipher.
 	// See the note below.
-	aeadAuthTagLen() (int, error)
+	AEADAuthTagLen() (int, error)
 	getRTCPIndex([]byte) uint32
 
 	encryptRTP([]byte, *rtp.Header, []byte, uint32) ([]byte, error)
diff --git a/srtp_cipher_aead_aes_gcm.go b/srtp_cipher_aead_aes_gcm.go
@@ -67,7 +67,7 @@ func newSrtpCipherAeadAesGcm(profile ProtectionProfile, masterKey, masterSalt []
 
 func (s *srtpCipherAeadAesGcm) encryptRTP(dst []byte, header *rtp.Header, payload []byte, roc uint32) (ciphertext []byte, err error) {
 	// Grow the given buffer to fit the output.
-	authTagLen, err := s.aeadAuthTagLen()
+	authTagLen, err := s.AEADAuthTagLen()
 	if err != nil {
 		return nil, err
 	}
@@ -85,7 +85,7 @@ func (s *srtpCipherAeadAesGcm) encryptRTP(dst []byte, header *rtp.Header, payloa
 
 func (s *srtpCipherAeadAesGcm) decryptRTP(dst, ciphertext []byte, header *rtp.Header, headerLen int, roc uint32) ([]byte, error) {
 	// Grow the given buffer to fit the output.
-	authTagLen, err := s.aeadAuthTagLen()
+	authTagLen, err := s.AEADAuthTagLen()
 	if err != nil {
 		return nil, err
 	}
@@ -109,7 +109,7 @@ func (s *srtpCipherAeadAesGcm) decryptRTP(dst, ciphertext []byte, header *rtp.He
 }
 
 func (s *srtpCipherAeadAesGcm) encryptRTCP(dst, decrypted []byte, srtcpIndex uint32, ssrc uint32) ([]byte, error) {
-	authTagLen, err := s.aeadAuthTagLen()
+	authTagLen, err := s.AEADAuthTagLen()
 	if err != nil {
 		return nil, err
 	}
@@ -130,7 +130,7 @@ func (s *srtpCipherAeadAesGcm) encryptRTCP(dst, decrypted []byte, srtcpIndex uin
 func (s *srtpCipherAeadAesGcm) decryptRTCP(dst, encrypted []byte, srtcpIndex, ssrc uint32) ([]byte, error) {
 	aadPos := len(encrypted) - srtcpIndexSize
 	// Grow the given buffer to fit the output.
-	authTagLen, err := s.aeadAuthTagLen()
+	authTagLen, err := s.AEADAuthTagLen()
 	if err != nil {
 		return nil, err
 	}
diff --git a/srtp_cipher_aes_cm_hmac_sha1.go b/srtp_cipher_aes_cm_hmac_sha1.go
@@ -49,7 +49,7 @@ func newSrtpCipherAesCmHmacSha1(profile ProtectionProfile, masterKey, masterSalt
 		return nil, err
 	}
 
-	authKeyLen, err := profile.authKeyLen()
+	authKeyLen, err := profile.AuthKeyLen()
 	if err != nil {
 		return nil, err
 	}
@@ -71,7 +71,7 @@ func newSrtpCipherAesCmHmacSha1(profile ProtectionProfile, masterKey, masterSalt
 
 func (s *srtpCipherAesCmHmacSha1) encryptRTP(dst []byte, header *rtp.Header, payload []byte, roc uint32) (ciphertext []byte, err error) {
 	// Grow the given buffer to fit the output.
-	authTagLen, err := s.rtpAuthTagLen()
+	authTagLen, err := s.AuthTagRTPLen()
 	if err != nil {
 		return nil, err
 	}
@@ -104,7 +104,7 @@ func (s *srtpCipherAesCmHmacSha1) encryptRTP(dst []byte, header *rtp.Header, pay
 
 func (s *srtpCipherAesCmHmacSha1) decryptRTP(dst, ciphertext []byte, header *rtp.Header, headerLen int, roc uint32) ([]byte, error) {
 	// Split the auth tag and the cipher text into two parts.
-	authTagLen, err := s.rtpAuthTagLen()
+	authTagLen, err := s.AuthTagRTPLen()
 	if err != nil {
 		return nil, err
 	}
@@ -156,7 +156,7 @@ func (s *srtpCipherAesCmHmacSha1) encryptRTCP(dst, decrypted []byte, srtcpIndex
 }
 
 func (s *srtpCipherAesCmHmacSha1) decryptRTCP(out, encrypted []byte, index, ssrc uint32) ([]byte, error) {
-	authTagLen, err := s.rtcpAuthTagLen()
+	authTagLen, err := s.AuthTagRTCPLen()
 	if err != nil {
 		return nil, err
 	}
@@ -213,7 +213,7 @@ func (s *srtpCipherAesCmHmacSha1) generateSrtpAuthTag(buf []byte, roc uint32) ([
 	}
 
 	// Truncate the hash to the size indicated by the profile
-	authTagLen, err := s.rtpAuthTagLen()
+	authTagLen, err := s.AuthTagRTPLen()
 	if err != nil {
 		return nil, err
 	}
@@ -237,7 +237,7 @@ func (s *srtpCipherAesCmHmacSha1) generateSrtcpAuthTag(buf []byte) ([]byte, erro
 	if _, err := s.srtcpSessionAuth.Write(buf); err != nil {
 		return nil, err
 	}
-	authTagLen, err := s.rtcpAuthTagLen()
+	authTagLen, err := s.AuthTagRTCPLen()
 	if err != nil {
 		return nil, err
 	}
@@ -246,7 +246,7 @@ func (s *srtpCipherAesCmHmacSha1) generateSrtcpAuthTag(buf []byte) ([]byte, erro
 }
 
 func (s *srtpCipherAesCmHmacSha1) getRTCPIndex(in []byte) uint32 {
-	authTagLen, _ := s.rtcpAuthTagLen()
+	authTagLen, _ := s.AuthTagRTCPLen()
 	tailOffset := len(in) - (authTagLen + srtcpIndexSize)
 	srtcpIndexBuffer := in[tailOffset : tailOffset+srtcpIndexSize]
 	return binary.BigEndian.Uint32(srtcpIndexBuffer) &^ (1 << 31)
diff --git a/srtp_cipher_test.go b/srtp_cipher_test.go
@@ -119,11 +119,11 @@ func createTestCiphers() []testCipher {
 	}
 
 	for k, v := range tests {
-		keyLen, err := v.profile.keyLen()
+		keyLen, err := v.profile.KeyLen()
 		if err != nil {
 			panic(err)
 		}
-		saltLen, err := v.profile.saltLen()
+		saltLen, err := v.profile.SaltLen()
 		if err != nil {
 			panic(err)
 		}
diff --git a/srtp_test.go b/srtp_test.go
@@ -37,10 +37,10 @@ func (tc rtpTestCase) encrypted(profile ProtectionProfile) []byte {
 }
 
 func testKeyLen(t *testing.T, profile ProtectionProfile) {
-	keyLen, err := profile.keyLen()
+	keyLen, err := profile.KeyLen()
 	assert.NoError(t, err)
 
-	saltLen, err := profile.saltLen()
+	saltLen, err := profile.SaltLen()
 	assert.NoError(t, err)
 
 	if _, err := CreateContext([]byte{}, make([]byte, saltLen), profile); err == nil {
@@ -181,11 +181,11 @@ func TestRolloverCountOverflow(t *testing.T) {
 }
 
 func buildTestContext(profile ProtectionProfile, opts ...ContextOption) (*Context, error) {
-	keyLen, err := profile.keyLen()
+	keyLen, err := profile.KeyLen()
 	if err != nil {
 		return nil, err
 	}
-	saltLen, err := profile.saltLen()
+	saltLen, err := profile.SaltLen()
 	if err != nil {
 		return nil, err
 	}
@@ -270,7 +270,7 @@ func rtpTestCases() []rtpTestCase {
 func testRTPLifecyleNewAlloc(t *testing.T, profile ProtectionProfile) {
 	assert := assert.New(t)
 
-	authTagLen, err := profile.rtpAuthTagLen()
+	authTagLen, err := profile.AuthTagRTPLen()
 	assert.NoError(err)
 
 	for _, testCase := range rtpTestCases() {
diff --git a/stream_srtp_test.go b/stream_srtp_test.go
@@ -67,11 +67,11 @@ func TestBufferFactory(t *testing.T) {
 func benchmarkWrite(b *testing.B, profile ProtectionProfile, size int) {
 	conn := newNoopConn()
 
-	keyLen, err := profile.keyLen()
+	keyLen, err := profile.KeyLen()
 	if err != nil {
 		b.Fatal(err)
 	}
-	saltLen, err := profile.saltLen()
+	saltLen, err := profile.SaltLen()
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -147,11 +147,11 @@ func benchmarkWriteRTP(b *testing.B, profile ProtectionProfile, size int) {
 		closed: make(chan struct{}),
 	}
 
-	keyLen, err := profile.keyLen()
+	keyLen, err := profile.KeyLen()
 	if err != nil {
 		b.Fatal(err)
 	}
-	saltLen, err := profile.saltLen()
+	saltLen, err := profile.SaltLen()
 	if err != nil {
 		b.Fatal(err)
 	}

Original file line number	Diff line number	Diff line change
`@@ -66,12 +66,12 @@ type Context struct {`
`66`	`66`	`//`
`67`	`67`	`// decCtx, err := srtp.CreateContext(key, salt, profile, srtp.SRTPReplayProtection(256))`
`68`	`68`	`func CreateContext(masterKey, masterSalt []byte, profile ProtectionProfile, opts ...ContextOption) (c *Context, err error) {`
`69`		`- keyLen, err := profile.keyLen()`
	`69`	`+ keyLen, err := profile.KeyLen()`
`70`	`70`	`if err != nil {`
`71`	`71`	`return nil, err`
`72`	`72`	`}`
`73`	`73`
`74`		`- saltLen, err := profile.saltLen()`
	`74`	`+ saltLen, err := profile.SaltLen()`
`75`	`75`	`if err != nil {`
`76`	`76`	`return nil, err`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ func TestValidSessionKeys(t *testing.T) {`
`32`	`32`	`t.Errorf("Session Salt % 02x does not match expected % 02x", sessionSalt, expectedSessionSalt)`
`33`	`33`	`}`
`34`	`34`
`35`		`- authKeyLen, err := ProtectionProfileAes128CmHmacSha1_80.authKeyLen()`
	`35`	`+ authKeyLen, err := ProtectionProfileAes128CmHmacSha1_80.AuthKeyLen()`
`36`	`36`	`assert.NoError(t, err)`
`37`	`37`
`38`	`38`	`sessionAuthTag, err := aesCmKeyDerivation(labelSRTPAuthenticationTag, masterKey, masterSalt, 0, authKeyLen)`
Original file line number	Diff line number	Diff line change
`@@ -14,12 +14,12 @@ type KeyingMaterialExporter interface {`
`14`	`14`	`// extracting them from DTLS. This behavior is defined in RFC5764:`
`15`	`15`	`// https://tools.ietf.org/html/rfc5764`
`16`	`16`	`func (c *Config) ExtractSessionKeysFromDTLS(exporter KeyingMaterialExporter, isClient bool) error {`
`17`		`- keyLen, err := c.Profile.keyLen()`
	`17`	`+ keyLen, err := c.Profile.KeyLen()`
`18`	`18`	`if err != nil {`
`19`	`19`	`return err`
`20`	`20`	`}`
`21`	`21`
`22`		`- saltLen, err := c.Profile.saltLen()`
	`22`	`+ saltLen, err := c.Profile.SaltLen()`
`23`	`23`	`if err != nil {`
`24`	`24`	`return err`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,8 @@ const (`
`17`	`17`	`ProtectionProfileAeadAes256Gcm ProtectionProfile = 0x0008`
`18`	`18`	`)`
`19`	`19`
`20`		`-func (p ProtectionProfile) keyLen() (int, error) {`
	`20`	`+// KeyLen returns length of encryption key in bytes.`
	`21`	`+func (p ProtectionProfile) KeyLen() (int, error) {`
`21`	`22`	`switch p {`
`22`	`23`	`case ProtectionProfileAes128CmHmacSha1_32, ProtectionProfileAes128CmHmacSha1_80, ProtectionProfileAeadAes128Gcm:`
`23`	`24`	`return 16, nil`
`@@ -28,7 +29,8 @@ func (p ProtectionProfile) keyLen() (int, error) {`
`28`	`29`	`}`
`29`	`30`	`}`
`30`	`31`
`31`		`-func (p ProtectionProfile) saltLen() (int, error) {`
	`32`	`+// SaltLen returns length of salt key in bytes.`
	`33`	`+func (p ProtectionProfile) SaltLen() (int, error) {`
`32`	`34`	`switch p {`
`33`	`35`	`case ProtectionProfileAes128CmHmacSha1_32, ProtectionProfileAes128CmHmacSha1_80:`
`34`	`36`	`return 14, nil`
`@@ -39,7 +41,8 @@ func (p ProtectionProfile) saltLen() (int, error) {`
`39`	`41`	`}`
`40`	`42`	`}`
`41`	`43`
`42`		`-func (p ProtectionProfile) rtpAuthTagLen() (int, error) {`
	`44`	`+// AuthTagRTPLen returns length of RTP authentication tag in bytes for AES protection profiles. For AEAD ones it returns zero.`
	`45`	`+func (p ProtectionProfile) AuthTagRTPLen() (int, error) {`
`43`	`46`	`switch p {`
`44`	`47`	`case ProtectionProfileAes128CmHmacSha1_80:`
`45`	`48`	`return 10, nil`
`@@ -52,7 +55,8 @@ func (p ProtectionProfile) rtpAuthTagLen() (int, error) {`
`52`	`55`	`}`
`53`	`56`	`}`
`54`	`57`
`55`		`-func (p ProtectionProfile) rtcpAuthTagLen() (int, error) {`
	`58`	`+// AuthTagRTCPLen returns length of RTCP authentication tag in bytes for AES protection profiles. For AEAD ones it returns zero.`
	`59`	`+func (p ProtectionProfile) AuthTagRTCPLen() (int, error) {`
`56`	`60`	`switch p {`
`57`	`61`	`case ProtectionProfileAes128CmHmacSha1_32, ProtectionProfileAes128CmHmacSha1_80:`
`58`	`62`	`return 10, nil`
`@@ -63,7 +67,8 @@ func (p ProtectionProfile) rtcpAuthTagLen() (int, error) {`
`63`	`67`	`}`
`64`	`68`	`}`
`65`	`69`
`66`		`-func (p ProtectionProfile) aeadAuthTagLen() (int, error) {`
	`70`	`+// AEADAuthTagLen returns length of authentication tag in bytes for AEAD protection profiles. For AES ones it returns zero.`
	`71`	`+func (p ProtectionProfile) AEADAuthTagLen() (int, error) {`
`67`	`72`	`switch p {`
`68`	`73`	`case ProtectionProfileAes128CmHmacSha1_32, ProtectionProfileAes128CmHmacSha1_80:`
`69`	`74`	`return 0, nil`
`@@ -74,7 +79,8 @@ func (p ProtectionProfile) aeadAuthTagLen() (int, error) {`
`74`	`79`	`}`
`75`	`80`	`}`
`76`	`81`
`77`		`-func (p ProtectionProfile) authKeyLen() (int, error) {`
	`82`	`+// AuthKeyLen returns length of authentication key in bytes for AES protection profiles. For AEAD ones it returns zero.`
	`83`	`+func (p ProtectionProfile) AuthKeyLen() (int, error) {`
`78`	`84`	`switch p {`
`79`	`85`	`case ProtectionProfileAes128CmHmacSha1_32, ProtectionProfileAes128CmHmacSha1_80:`
`80`	`86`	`return 20, nil`
`@@ -85,6 +91,7 @@ func (p ProtectionProfile) authKeyLen() (int, error) {`
`85`	`91`	`}`
`86`	`92`	`}`
`87`	`93`
	`94`	`+// String returns the name of the protection profile.`
`88`	`95`	`func (p ProtectionProfile) String() string {`
`89`	`96`	`switch p {`
`90`	`97`	`case ProtectionProfileAes128CmHmacSha1_80:`
Original file line number	Diff line number	Diff line change
`@@ -341,7 +341,7 @@ func TestSessionSRTCPAcceptStreamTimeout(t *testing.T) {`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`func getSenderSSRC(t testing.T, stream ReadStreamSRTCP) (ssrc uint32, err error) {`
`344`		`- authTagSize, err := ProtectionProfileAes128CmHmacSha1_80.rtcpAuthTagLen()`
	`344`	`+ authTagSize, err := ProtectionProfileAes128CmHmacSha1_80.AuthTagRTCPLen()`
`345`	`345`	`if err != nil {`
`346`	`346`	`return 0, err`
`347`	`347`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,11 +15,11 @@ const maxSRTCPIndex = 0x7FFFFFFF`
`15`	`15`	`func (c *Context) decryptRTCP(dst, encrypted []byte) ([]byte, error) {`
`16`	`16`	`out := allocateIfMismatch(dst, encrypted)`
`17`	`17`
`18`		`- authTagLen, err := c.cipher.rtcpAuthTagLen()`
	`18`	`+ authTagLen, err := c.cipher.AuthTagRTCPLen()`
`19`	`19`	`if err != nil {`
`20`	`20`	`return nil, err`
`21`	`21`	`}`
`22`		`- aeadAuthTagLen, err := c.cipher.aeadAuthTagLen()`
	`22`	`+ aeadAuthTagLen, err := c.cipher.AEADAuthTagLen()`
`23`	`23`	`if err != nil {`
`24`	`24`	`return nil, err`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ import (`
`9`	`9`	`)`
`10`	`10`
`11`	`11`	`func (c Context) decryptRTP(dst, ciphertext []byte, header rtp.Header, headerLen int) ([]byte, error) {`
`12`		`- authTagLen, err := c.cipher.rtpAuthTagLen()`
	`12`	`+ authTagLen, err := c.cipher.AuthTagRTPLen()`
`13`	`13`	`if err != nil {`
`14`	`14`	`return nil, err`
`15`	`15`	`}`