package/gortsplib
1
0
Fork 0
mirror of https://github.com/aler9/gortsplib synced 2025-10-09 09:00:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

formatdecenc: fix crash in MJPEG decoder; add fuzz tests

Browse Source
This commit is contained in:
aler9
2023-01-07 16:43:45 +01:00
parent 441a90a519
commit 0499d99e83
46 changed files with 232 additions and 582 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
pkg/formatdecenc/rtph264/decoder_test.go
View File

@@ -452,188 +452,21 @@ func TestDecodeUntilMarker(t *testing.T) {
require.Equal(t, [][]byte{{0x01, 0x02}, {0x01, 0x02}}, nalus) require.Equal(t, [][]byte{{0x01, 0x02}, {0x01, 0x02}}, nalus)
} }
func TestDecodeErrors(t *testing.T) { func FuzzDecoderUnmarshal(f *testing.F) {
for _, ca := range []struct { d := &Decoder{}
name string d.Init()
pkts []*rtp.Packet
err string
}{
{
"missing payload",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
},
},
"payload is too short",
},
{
"STAP-A without NALUs",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x18},
},
},
"STAP-A packet doesn't contain any NALU",
},
{
"STAP-A without size",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x18, 0x01},
},
},
"invalid STAP-A packet (invalid size)",
},
{
"STAP-A with invalid size",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x18, 0x00, 0x15},
},
},
"invalid STAP-A packet (invalid size)",
},
{
"FU-A without payload",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x1c},
},
},
"invalid FU-A packet (invalid size)",
},
{
"FU-A with start and end bit",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17646,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x1c, 0b11000000},
},
},
"invalid FU-A packet (can't contain both a start and end bit)",
},
{
"FU-A non-starting 1",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17646,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x1c, 0b01000000},
},
},
"received a non-starting fragment without any previous starting fragment",
},
{
"FU-A non-starting 2",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: mergeBytes(
[]byte{0x05},
bytes.Repeat([]byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}, 8),
),
},
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17646,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x1c, 0b01000000},
},
},
"invalid FU-A packet (non-starting)",
},
{
"MTAP",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: false,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x1a},
},
},
"packet type not supported (MTAP-16)",
},
} {
t.Run(ca.name, func(t *testing.T) {
d := &Decoder{}
d.Init()
var lastErr error f.Fuzz(func(t *testing.T, b []byte) {
for _, pkt := range ca.pkts { d.Decode(&rtp.Packet{
_, _, lastErr = d.Decode(pkt) Header: rtp.Header{
} Version: 2,
require.EqualError(t, lastErr, ca.err) Marker: false,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: b,
}) })
} })
} }

2
pkg/formatdecenc/rtph264/testdata/fuzz/FuzzDecoderUnmarshal/048b606517c23baffac96520675af386f92f471f22f098caec184d581dd6292e vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("800")

2
pkg/formatdecenc/rtph264/testdata/fuzz/FuzzDecoderUnmarshal/17ec193e17dd91d1b2a621884383564489d9f873db1b015a693c79fb7c1c1a46 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("\x1c\xd4")

2
pkg/formatdecenc/rtph264/testdata/fuzz/FuzzDecoderUnmarshal/55cc57e8de6f7821309a6444040480f3aa0128b6b6cd96325b7997ff47d5d29d vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("8")

2
pkg/formatdecenc/rtph264/testdata/fuzz/FuzzDecoderUnmarshal/c30437d5edf1393c2957896ca6c4e4d0467a50451fd1feb1cae249fdcbf25a5a vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("\x1c")

2
pkg/formatdecenc/rtph264/testdata/fuzz/FuzzDecoderUnmarshal/c89423ac94e1743f63fb142431eed08c3b74e51a4e7b8ed44a1ba826ca6129d9 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("9")

2
pkg/formatdecenc/rtph264/testdata/fuzz/FuzzDecoderUnmarshal/caf81e9797b19c76c1fc4dbf537d4d81f389524539f402d13aa01f93a65ac7e9 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("")

2
pkg/formatdecenc/rtph264/testdata/fuzz/FuzzDecoderUnmarshal/f428976a5b2917c009d1f28d7a96e81095be8631f062798130aa7e6835b67b01 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("80")

2
pkg/formatdecenc/rtph264/testdata/fuzz/FuzzDecoderUnmarshal/fe107a097efccd5098d6b0147ef4b39f0e467f0257dbf8f8b2f256c235640a6e vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("\x1c0")

194
pkg/formatdecenc/rtph265/decoder_test.go
View File

@@ -174,185 +174,21 @@ func TestDecode(t *testing.T) {
} }
} }
func TestDecodeErrors(t *testing.T) { func FuzzDecoderUnmarshal(f *testing.F) {
for _, ca := range []struct { d := &Decoder{}
name string d.Init()
pkts []*rtp.Packet
err string
}{
{
"missing payload",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
},
},
"payload is too short",
},
{
"aggregation unit no size",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{48 << 1, 0x00, 0x01},
},
},
"invalid aggregation unit (invalid size)",
},
{
"aggregation unit invalid size",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{48 << 1, 0x00, 0x00, 0x05, 0x00},
},
},
"invalid aggregation unit (invalid size)",
},
{
"aggregation unit no NALUs",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{48 << 1, 0x00, 0x00, 0x00},
},
},
"aggregation unit doesn't contain any NALU",
},
{
"fragmentation unit invalid",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{49 << 1, 0x00},
},
},
"payload is too short",
},
{
"fragmentation unit start and end bit",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{49 << 1, 0x00, 0b11000000},
},
},
"invalid fragmentation unit (can't contain both a start and end bit)",
},
{
"fragmentation unit non-starting 1",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{49 << 1, 0x00, 0b01000000},
},
},
"received a non-starting fragment without any previous starting fragment",
},
{
"fragmentation unit non-starting 2",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x01, 0x00},
},
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{49 << 1, 0x00, 0b00000000},
},
},
"invalid fragmentation unit (non-starting)",
},
{
"paci",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: []byte{50 << 1, 0x00},
},
},
"PACI packets are not supported (yet)",
},
} {
t.Run(ca.name, func(t *testing.T) {
d := &Decoder{}
d.Init()
var lastErr error f.Fuzz(func(t *testing.T, b []byte) {
for _, pkt := range ca.pkts { d.Decode(&rtp.Packet{
_, _, lastErr = d.Decode(pkt) Header: rtp.Header{
} Version: 2,
require.EqualError(t, lastErr, ca.err) Marker: false,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: b,
}) })
} })
} }

2
pkg/formatdecenc/rtph265/testdata/fuzz/FuzzDecoderUnmarshal/353ba911ad2dc1916f0bb9eb5e553575e27c9a6662e86d265f55bd57d1746962 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("a00")

2
pkg/formatdecenc/rtph265/testdata/fuzz/FuzzDecoderUnmarshal/6e0463cbdc2d559f2823538d2efee4a8b811c3ea02d2bd8e0f306d81382d5698 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("a0")

2
pkg/formatdecenc/rtph265/testdata/fuzz/FuzzDecoderUnmarshal/95aa14d7ab02ec8b5c470dcc780587540caba1589c6a7ce702ff84edca9b3133 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("d0")

2
pkg/formatdecenc/rtph265/testdata/fuzz/FuzzDecoderUnmarshal/c4389a565e8280502fc611cde347896b5d167806b2e49e22db23bed73deef75b vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("a000")

2
pkg/formatdecenc/rtph265/testdata/fuzz/FuzzDecoderUnmarshal/caf81e9797b19c76c1fc4dbf537d4d81f389524539f402d13aa01f93a65ac7e9 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("")

2
pkg/formatdecenc/rtph265/testdata/fuzz/FuzzDecoderUnmarshal/cb84a08ac93f5772ee3ba0f0bcfde81c9cd71a403c69f893cebc8378c60af625 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("bbbbbbbbbbbbb0")

2
pkg/formatdecenc/rtph265/testdata/fuzz/FuzzDecoderUnmarshal/e45ead12fae619dd0807aaf83341d58eca4d50fab6eefbe78953581a1a4df198 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("b0\xcd")

2
pkg/formatdecenc/rtph265/testdata/fuzz/FuzzDecoderUnmarshal/eb4593a9592045ab0cf0b17a3f9f2754d6898ee465ec32d9e08392bcbab0a81a vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("b0")

23
pkg/formatdecenc/rtplpcm/decoder_test.go
View File

@@ -106,3 +106,26 @@ func TestDecode(t *testing.T) {
}) })
} }
} }
func FuzzDecoderUnmarshal(f *testing.F) {
d := &Decoder{
BitDepth: 24,
SampleRate: 48000,
ChannelCount: 2,
}
d.Init()
f.Fuzz(func(t *testing.T, b []byte) {
d.Decode(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: false,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: b,
})
})
}

2
pkg/formatdecenc/rtplpcm/testdata/fuzz/FuzzDecoderUnmarshal/582528ddfad69eb57775199a43e0f9fd5c94bba343ce7bb6724d4ebafe311ed4 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("0")

4
pkg/formatdecenc/rtpmjpeg/decoder.go
View File

@@ -167,6 +167,10 @@ func (d *Decoder) Decode(pkt *rtp.Packet) ([]byte, time.Duration, error) {
return nil, 0, ErrMorePacketsNeeded return nil, 0, ErrMorePacketsNeeded
} }
if d.fragmentedSize < 2 {
return nil, 0, fmt.Errorf("invalid data")
}
data := make([]byte, d.fragmentedSize) data := make([]byte, d.fragmentedSize)
pos := 0 pos := 0

19
pkg/formatdecenc/rtpmjpeg/decoder_test.go
View File

@@ -527,3 +527,22 @@ func TestDecode(t *testing.T) {
}) })
} }
} }
func FuzzDecoderUnmarshal(f *testing.F) {
d := &Decoder{}
d.Init()
f.Fuzz(func(t *testing.T, b []byte, m bool) {
d.Decode(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: m,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: b,
})
})
}

3
pkg/formatdecenc/rtpmjpeg/testdata/fuzz/FuzzDecoderUnmarshal/52b2e47791e6e8c660670149d685c83d5fecefd94c322f710147669ef887e099 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("0")
bool(false)

3
pkg/formatdecenc/rtpmjpeg/testdata/fuzz/FuzzDecoderUnmarshal/76a6865e7bb36d841a943abed143b3403b2d0ffaecdf3298988189c118ee10c1 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("0\x00\x00\x00\x01\xff000\x00\x00@0000000000000000000000000000000000000000000000000000000000000000")
bool(true)

3
pkg/formatdecenc/rtpmjpeg/testdata/fuzz/FuzzDecoderUnmarshal/bbed53e53be4cad7bab7f568e12dda0590d7c11c0f890b3816ab6eff536ac9fc vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("0000\x01\xff00000000000000000000000000000000000000000000000000000000000000000000000")
bool(true)

3
pkg/formatdecenc/rtpmjpeg/testdata/fuzz/FuzzDecoderUnmarshal/be012bfe6e99e126df96e194dc125f8c57860dd62c4244dd7b4e7512cb22a205 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("0000\x01\xff00")
bool(false)

3
pkg/formatdecenc/rtpmjpeg/testdata/fuzz/FuzzDecoderUnmarshal/c2ffebd2c319dea9e791ab793c970d84bc212c35134cc2dfb85aa7d862858a49 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("0\x00\x00\x00\x01\xff00")
bool(false)

3
pkg/formatdecenc/rtpmjpeg/testdata/fuzz/FuzzDecoderUnmarshal/fe09b7699690e38a634478835482b418adf4885a063409efe36d0d6120af5eb9 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("0000\x01\xff00000000000000000000000000000000000000000000000000000000000000000000000")
bool(false)

242
pkg/formatdecenc/rtpmpeg4audio/decoder_test.go
View File

@@ -579,226 +579,26 @@ func TestDecodeADTS(t *testing.T) {
} }
} }
func TestDecodeErrors(t *testing.T) { func FuzzDecoderUnmarshal(f *testing.F) {
for _, ca := range []struct { d := &Decoder{
name string SampleRate: 16000,
pkts []*rtp.Packet SizeLength: 13,
err string IndexLength: 3,
}{ IndexDeltaLength: 3,
{
"missing payload",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 0x60,
SequenceNumber: 0x44ed,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
},
},
"payload is too short",
},
{
"missing au header",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 0x60,
SequenceNumber: 0x44ed,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x00, 0x10},
},
},
"not enough bits",
},
{
"missing au",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 0x60,
SequenceNumber: 0x44ed,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x00, 0x10, 0x0a, 0xd8},
},
},
"payload is too short",
},
{
"invalid au headers length",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 0x60,
SequenceNumber: 0x44ed,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x00, 0x00},
},
},
"invalid AU-headers-length",
},
{
"au index not zero",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 0x60,
SequenceNumber: 0x44ed,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x00, 0x10, 0x0a, 0xd9},
},
},
"AU-index different than zero is not supported",
},
{
"au index delta not zero",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 0x60,
SequenceNumber: 0x44ed,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x00, 0x20, 0x00, 0x08, 0x0a, 0xd9},
},
},
"AU-index-delta different than zero is not supported",
},
{
"fragmented with multiple AUs in 1st packet",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: false,
PayloadType: 0x60,
SequenceNumber: 0xea2,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x00, 0x20, 0x00, 0x08, 0x00, 0x08},
},
},
"a fragmented packet can only contain one AU",
},
{
"fragmented with no payload in 1st packet",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: false,
PayloadType: 0x60,
SequenceNumber: 0x44ed,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x00, 0x10, 0x0a, 0xd8},
},
},
"payload is too short",
},
{
"fragmented with multiple AUs in 2nd packet",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: false,
PayloadType: 0x60,
SequenceNumber: 0x44ed,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: mergeBytes(
[]byte{0x0, 0x10, 0x2d, 0x80},
bytes.Repeat([]byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}, 182),
),
},
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 0x60,
SequenceNumber: 0x44ee,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: mergeBytes(
[]byte{0x0, 0x20, 0x00, 0x08, 0x00, 0x08},
),
},
},
"a fragmented packet can only contain one AU",
},
{
"fragmented with no payload in 2nd packet",
[]*rtp.Packet{
{
Header: rtp.Header{
Version: 2,
Marker: false,
PayloadType: 0x60,
SequenceNumber: 0x44ed,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: mergeBytes(
[]byte{0x0, 0x10, 0x2d, 0x80},
bytes.Repeat([]byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}, 182),
),
},
{
Header: rtp.Header{
Version: 2,
Marker: true,
PayloadType: 0x60,
SequenceNumber: 0x44ee,
Timestamp: 0x88776a15,
SSRC: 0x9dbb7812,
},
Payload: []byte{0x00, 0x10, 0x0a, 0xd8},
},
},
"payload is too short",
},
} {
t.Run(ca.name, func(t *testing.T) {
d := &Decoder{
SampleRate: 48000,
SizeLength: 13,
IndexLength: 3,
IndexDeltaLength: 3,
}
d.Init()
var lastErr error
for _, pkt := range ca.pkts {
_, _, lastErr = d.Decode(pkt)
}
require.EqualError(t, lastErr, ca.err)
})
} }
d.Init()
f.Fuzz(func(t *testing.T, b []byte, m bool) {
d.Decode(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: m,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: b,
})
})
} }

3
pkg/formatdecenc/rtpmpeg4audio/testdata/fuzz/FuzzDecoderUnmarshal/17b3f3cab1067ee0ee8464bd3f7890cc1a42ed3f47f13ee83ffdc3ddec1879ef vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("\x00\x0100")
bool(false)

3
pkg/formatdecenc/rtpmpeg4audio/testdata/fuzz/FuzzDecoderUnmarshal/17f38ee4db10b1296a5bdbd03e35ab29e7e86c1008f89d4437529302df6ecb59 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("000001")
bool(false)

3
pkg/formatdecenc/rtpmpeg4audio/testdata/fuzz/FuzzDecoderUnmarshal/38d1a2c06720135e2d5accd1afc1f312bc4b6991cd97c1444c86690b4ed6df70 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("\x000000000")
bool(true)

3
pkg/formatdecenc/rtpmpeg4audio/testdata/fuzz/FuzzDecoderUnmarshal/4c3e593e59c1f853f845a7e3c992d1837f63c5052d805c21db6734a64c3ee1e0 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("\x00\x00")
bool(true)

3
pkg/formatdecenc/rtpmpeg4audio/testdata/fuzz/FuzzDecoderUnmarshal/52b2e47791e6e8c660670149d685c83d5fecefd94c322f710147669ef887e099 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("0")
bool(false)

3
pkg/formatdecenc/rtpmpeg4audio/testdata/fuzz/FuzzDecoderUnmarshal/7b9886f07cd0d1b52d80762d475eda9b446e4861160e9a79b294eeb75345ebc5 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("0001")
bool(true)

3
pkg/formatdecenc/rtpmpeg4audio/testdata/fuzz/FuzzDecoderUnmarshal/82ab2d91fd10f5f409473e000b93d979dcea2547839dece510544e4f2243b80b vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("00")
bool(true)

3
pkg/formatdecenc/rtpmpeg4audio/testdata/fuzz/FuzzDecoderUnmarshal/a253c894d4f7ea0c24ff61014f52a33011acd37d246b6e81527f5544c00140b6 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("\x00\x0100")
bool(true)

3
pkg/formatdecenc/rtpmpeg4audio/testdata/fuzz/FuzzDecoderUnmarshal/a2d4352b624b7e9e5fefbc9881be89bcf82806ed6644dbb3c0914215e484c015 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("\x00\x10\x80\x00")
bool(false)

3
pkg/formatdecenc/rtpmpeg4audio/testdata/fuzz/FuzzDecoderUnmarshal/fc47c4c80ffd62dfd9c7adf40b38f9d9fe0bf9466af436b5c3487f2c4b9b90e4 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("\x000000000")
bool(false)

19
pkg/formatdecenc/rtpvp8/decoder_test.go
View File

@@ -131,3 +131,22 @@ func TestDecode(t *testing.T) {
}) })
} }
} }
func FuzzDecoderUnmarshal(f *testing.F) {
d := &Decoder{}
d.Init()
f.Fuzz(func(t *testing.T, b []byte, m bool) {
d.Decode(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: m,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: b,
})
})
}

3
pkg/formatdecenc/rtpvp8/testdata/fuzz/FuzzDecoderUnmarshal/52b2e47791e6e8c660670149d685c83d5fecefd94c322f710147669ef887e099 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("0")
bool(false)

3
pkg/formatdecenc/rtpvp8/testdata/fuzz/FuzzDecoderUnmarshal/7a1c68afba07c13a12f3686c52a228b2ca8d9794363a61529fcad02658ea03e3 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte(" 000")
bool(false)

3
pkg/formatdecenc/rtpvp8/testdata/fuzz/FuzzDecoderUnmarshal/c4c11fb7d7de62a02ee8e7d6962d074d82fa5fdd472096dc3ba35696d1649fa4 vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("1000")
bool(false)

19
pkg/formatdecenc/rtpvp9/decoder_test.go
View File

@@ -132,3 +132,22 @@ func TestDecode(t *testing.T) {
}) })
} }
} }
func FuzzDecoderUnmarshal(f *testing.F) {
d := &Decoder{}
d.Init()
f.Fuzz(func(t *testing.T, b []byte, m bool) {
d.Decode(&rtp.Packet{
Header: rtp.Header{
Version: 2,
Marker: m,
PayloadType: 96,
SequenceNumber: 17645,
Timestamp: 2289527317,
SSRC: 0x9dbb7812,
},
Payload: b,
})
})
}

3
pkg/formatdecenc/rtpvp9/testdata/fuzz/FuzzDecoderUnmarshal/a562b457d1a04bb296308020307f2e271491c804e84959ad2d5fdaa2e32b6a0f vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("")
bool(true)

3
pkg/formatdecenc/rtpvp9/testdata/fuzz/FuzzDecoderUnmarshal/ef9d289981397c05db640a6c59c3451a32320b9343d5fefb3e03f72b36377a6c vendored Normal file
View File

@@ -0,0 +1,3 @@
go test fuzz v1
[]byte("00")
bool(false)