format_parser 2.4.3 → 2.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ed2f3d1a503aee2a0b68f00dfae5253fa88cb9ab95b61066642749785542c06
-  data.tar.gz: 3cac7120ef119969273568714fa3f75c07e3493bd80c18b89e4a7ac93efbc9dd
+  metadata.gz: 7daa912b01159c41fc44b099188bac919984d4e0d75000acc7053e221b719f06
+  data.tar.gz: d081b9d2e1bbe5458b1ca57a5d1140c4cf1ad289a2d1af8557093c201b6969b4
 SHA512:
-  metadata.gz: 311393234d4bc595a81169dcfa658b872c539179fba29149d7794df64d388ebbad7e1bdbf8f963018b438c3ad0a350a1f23f47fd1a383a0d50d6897f429c727c
-  data.tar.gz: e73d90e24cef65d936eebd0765403b3d83e52fdb6bf3640bfabba2afd2b059d4a85a1010fca6ff575e6e0ff84e003cc75fa1bb4a8cb2adbff0c1fb55e97161d1
+  metadata.gz: 8e19114d58216267ea215e91f6ec0d616eb58459d0a052f755decdb7fc3f7b7d653f6ab17a79d12e09039df538d2c7361cdee44e015802378489ca186e333fbc
+  data.tar.gz: c1a3b6fe0c05ec3002e1f823f14d06d95eec0f96f411190970fa954080827f08ca14ecb50b638edd23155c72f76b14da7ba305770adffa120b329a39c7557033

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.4.5
+* Disable `udta` ISOBMFF box parsing, since their contents are not guaranteed to be consistent with the spec.
+
+## 2.4.4
+* Prevent infinite loops when parsing ISOBMFF boxes with size = 0 (meaning that the box extends to the end of the file).
+
 ## 2.4.3
 * Improve resiliency in ISOBMFF parsing to missing mandatory boxes and fields.
 * Simplify ISOBMFF frame rate calculations.

data/lib/format_parser/version.rb

@@ -1,3 +1,3 @@
 module FormatParser
-  VERSION = '2.4.3'
+  VERSION = '2.4.5'
 end

data/lib/parsers/iso_base_media_file_format/decoder.rb

@@ -116,7 +116,7 @@ module FormatParser
         'trak' => :container,
         # 'trex' => :trex,
         # 'tsel' => :tsel,
-        'udta' => :container,
+        # 'udta' => :container,
         # 'url ' => :dref_url,
         # 'urn ' => :dref_urn,
         'uuid' => :uuid,
@@ -129,10 +129,15 @@ module FormatParser
       # @return [Box, nil]
       def parse_box
         position = @buf.pos
-
         size = read_int
         type = read_string(4)
-        size = read_int(n: 8) if size == 1
+
+        if size == 1
+          size = read_int(n: 8)
+        elsif size == 0
+          size = @buf.size - position
+        end
+
         body_size = size - (@buf.pos - position)
         next_box_position = position + size
 

data/spec/parsers/iso_base_media_file_format/decoder_spec.rb

@@ -48,12 +48,29 @@ describe FormatParser::ISOBaseMediaFileFormat::Decoder do
       end
       let(:result) { subject.build_box_tree(0xFF, io) }
 
-      it('parses successfully') { expect(result.length).to eq(1) }
-      it('parses the correct type') { expect(result[0].type).to eq('foo ') }
-      it('parses the correct position') { expect(result[0].position).to eq(0) }
-      it('parses the correct size') { expect(result[0].size).to eq(0x14) }
-      it('skips additional fields') { expect(result[0].fields).to eq({}) }
-      it('skips children') { expect(result[0].children).to eq([]) }
+      it 'parses successfully' do
+        expect(result.length).to eq(1)
+      end
+
+      it 'parses the correct type' do
+        expect(result[0].type).to eq('foo ')
+      end
+
+      it 'parses the correct position' do
+        expect(result[0].position).to eq(0)
+      end
+
+      it 'parses the correct size' do
+        expect(result[0].size).to eq(0x14)
+      end
+
+      it 'skips additional fields' do
+        expect(result[0].fields).to eq({})
+      end
+
+      it 'skips children' do
+        expect(result[0].children).to eq([])
+      end
     end
 
     context 'when parsing a container box' do
@@ -66,12 +83,29 @@ describe FormatParser::ISOBaseMediaFileFormat::Decoder do
       end
       let(:result) { subject.build_box_tree(0xFF, io) }
 
-      it('parses successfully') { expect(result.length).to eq(1) }
-      it('parses the correct type') { expect(result[0].type).to eq('moov') }
-      it('parses the correct position') { expect(result[0].position).to eq(0) }
-      it('parses the correct size') { expect(result[0].size).to eq(0x18) }
-      it('skips additional fields') { expect(result[0].fields).to eq({}) }
-      it('parses children') { expect(result[0].children.length).to eq(2) }
+      it 'parses successfully' do
+        expect(result.length).to eq(1)
+      end
+
+      it 'parses the correct type' do
+        expect(result[0].type).to eq('moov')
+      end
+
+      it 'parses the correct position' do
+        expect(result[0].position).to eq(0)
+      end
+
+      it 'parses the correct size' do
+        expect(result[0].size).to eq(0x18)
+      end
+
+      it 'skips additional fields' do
+        expect(result[0].fields).to eq({})
+      end
+
+      it 'parses children' do
+        expect(result[0].children.length).to eq(2)
+      end
     end
 
     context 'when parsing an empty box' do
@@ -83,17 +117,32 @@ describe FormatParser::ISOBaseMediaFileFormat::Decoder do
       end
       let(:result) { subject.build_box_tree(0xFF, io) }
 
-      it('parses successfully') { expect(result.length).to eq(1) }
-      it('parses the correct type') { expect(result[0].type).to eq('nmhd') }
-      it('parses the correct position') { expect(result[0].position).to eq(0) }
-      it('parses the correct size') { expect(result[0].size).to eq(0x18) }
-      it('parses version and flags') do
+      it 'parses successfully' do
+        expect(result.length).to eq(1)
+      end
+
+      it 'parses the correct type' do
+        expect(result[0].type).to eq('nmhd')
+      end
+
+      it 'parses the correct position' do
+        expect(result[0].position).to eq(0)
+      end
+
+      it 'parses the correct size' do
+        expect(result[0].size).to eq(0x18)
+      end
+
+      it 'parses version and flags' do
         expect(result[0].fields).to include({
           version: 1,
           flags: 'fla'
         })
       end
-      it('skips children') { expect(result[0].children).to eq([]) }
+
+      it 'skips children' do
+        expect(result[0].children).to eq([])
+      end
     end
 
     context 'when parsing a uuid box' do
@@ -106,12 +155,54 @@ describe FormatParser::ISOBaseMediaFileFormat::Decoder do
       end
       let(:result) { subject.build_box_tree(0xFF, io) }
 
-      it('parses successfully') { expect(result.length).to eq(1) }
-      it('parses the correct type') { expect(result[0].type).to eq('uuid') }
-      it('parses the correct position') { expect(result[0].position).to eq(0) }
-      it('parses the correct size') { expect(result[0].size).to eq(0x20) }
-      it('parses usertype') { expect(result[0].fields).to include({ usertype: usertype }) }
-      it('skips children') { expect(result[0].children).to eq([]) }
+      it 'parses successfully' do
+        expect(result.length).to eq(1)
+      end
+
+      it 'parses the correct type' do
+        expect(result[0].type).to eq('uuid')
+      end
+
+      it 'parses the correct position' do
+        expect(result[0].position).to eq(0)
+      end
+
+      it 'parses the correct size' do
+        expect(result[0].size).to eq(0x20)
+      end
+
+      it 'parses usertype' do
+        expect(result[0].fields).to include({ usertype: usertype })
+      end
+
+      it 'skips children' do
+        expect(result[0].children).to eq([])
+      end
+    end
+
+    context 'when parsing a box with 0 size' do
+      let(:io) do
+        # foo
+        # moov
+        # |-> bar
+        # |-> baz
+        input = [0x8].pack('N') + 'foo ' + [0x0].pack('N') + 'moov' + [0x8].pack('N') + 'bar ' + [0x8].pack('N') + 'baz '
+        StringIO.new(input)
+      end
+      let(:result) { subject.build_box_tree(0xFF, io) }
+
+      it 'reads the rest of the file' do
+        expect(result.length).to eq(2)
+        expect(io.pos).to eq(0x20)
+      end
+
+      it 'parses correctly' do
+        expect(result[0].type).to eq('foo ')
+        expect(result[1].type).to eq('moov')
+        expect(result[1].children.length).to eq(2)
+        expect(result[1].children[0].type).to eq('bar ')
+        expect(result[1].children[1].type).to eq('baz ')
+      end
     end
   end
 end

data/spec/parsers/mov_parser_spec.rb

@@ -35,15 +35,41 @@ describe FormatParser::MOVParser do
       context "for #{path}" do
         let(:result) { subject.call(File.open(path, 'rb')) }
 
-        it('should not be nil') { expect(result).not_to be_nil }
-        it('should have video nature') { expect(result.nature).to eq(:video) }
-        it('should have MOV video content type') { expect(result.content_type).to eq('video/quicktime') }
-        it('should have MOV video format') { expect(result.format).to eq(:mov) }
-        it('should have a non-zero height ') { expect(result.height_px).to be > 0 }
-        it('should have a non-zero width') { expect(result.width_px).to be > 0 }
-        it('should have a non-zero duration') { expect(result.media_duration_seconds).to be > 0 }
-        it('should have a non-nil frame rate') { expect(result.frame_rate).not_to be_nil }
-        it('should have intrinsics') { expect(result.intrinsics).not_to be_nil }
+        it 'should not be nil' do
+          expect(result).not_to be_nil
+        end
+
+        it 'should have video nature' do
+          expect(result.nature).to eq(:video)
+        end
+
+        it 'should have MOV video content type' do
+          expect(result.content_type).to eq('video/quicktime')
+        end
+
+        it 'should have MOV video format' do
+          expect(result.format).to eq(:mov)
+        end
+
+        it 'should have a non-zero height ' do
+          expect(result.height_px).to be > 0
+        end
+
+        it 'should have a non-zero width' do
+          expect(result.width_px).to be > 0
+        end
+
+        it 'should have a non-zero duration' do
+          expect(result.media_duration_seconds).to be > 0
+        end
+
+        it 'should have a non-nil frame rate' do
+          expect(result.frame_rate).not_to be_nil
+        end
+
+        it 'should have intrinsics' do
+          expect(result.intrinsics).not_to be_nil
+        end
       end
     end
 
@@ -51,7 +77,9 @@ describe FormatParser::MOVParser do
       context "for #{path}" do
         let(:result) { subject.call(File.open(path, 'rb')) }
 
-        it('should be nil') { expect(result).to be_nil }
+        it 'should be nil' do
+          expect(result).to be_nil
+        end
       end
     end
 
@@ -61,10 +89,21 @@ describe FormatParser::MOVParser do
         subject.call(File.open(path, 'rb'))
       end
 
-      it('should have the correct height') { expect(result.height_px).to eq(360) }
-      it('should have the correct width') { expect(result.width_px).to eq(640) }
-      it('should have the correct duration') { expect(result.media_duration_seconds.truncate(2)).to eq(9.36) }
-      it('should have the correct frame rate') { expect(result.frame_rate).to eq(30) }
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(360)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(640)
+      end
+
+      it 'should have the correct duration' do
+        expect(result.media_duration_seconds.truncate(2)).to eq(9.36)
+      end
+
+      it 'should have the correct frame rate' do
+        expect(result.frame_rate).to eq(30)
+      end
     end
 
     context "for a scaled MOV video" do
@@ -73,8 +112,13 @@ describe FormatParser::MOVParser do
         subject.call(File.open(path, 'rb'))
       end
 
-      it('should have the correct height') { expect(result.height_px).to eq(720) }
-      it('should have the correct width') { expect(result.width_px).to eq(1280) }
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(720)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(1280)
+      end
     end
 
     context "for a rotated MOV video" do
@@ -83,8 +127,13 @@ describe FormatParser::MOVParser do
         subject.call(File.open(path, 'rb'))
       end
 
-      it('should have the correct height') { expect(result.height_px).to eq(640) }
-      it('should have the correct width') { expect(result.width_px).to eq(360) }
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(640)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(360)
+      end
     end
   end
 end

data/spec/parsers/mp4_parser_spec.rb

@@ -35,15 +35,41 @@ describe FormatParser::MP4Parser do
       context "for #{path}" do
         let(:result) { subject.call(File.open(path, 'rb')) }
 
-        it('should not be nil') { expect(result).not_to be_nil }
-        it('should have video nature') { expect(result.nature).to eq(:video) }
-        it('should have MP4 video content type') { expect(result.content_type).to eq('video/mp4') }
-        it('should have MP4 video format') { expect([:mp4, :mv4]).to include(result.format) }
-        it('should have a non-zero height ') { expect(result.height_px).to be > 0 }
-        it('should have a non-zero width') { expect(result.width_px).to be > 0 }
-        it('should have a non-zero duration') { expect(result.media_duration_seconds).to be > 0 }
-        it('should have a non-nil frame rate') { expect(result.frame_rate).not_to be_nil }
-        it('should have intrinsics') { expect(result.intrinsics).not_to be_nil }
+        it 'should not be nil' do
+          expect(result).not_to be_nil
+        end
+
+        it 'should have video nature' do
+          expect(result.nature).to eq(:video)
+        end
+
+        it 'should have MP4 video content type' do
+          expect(result.content_type).to eq('video/mp4')
+        end
+
+        it 'should have MP4 video format' do
+          expect([:mp4, :mv4]).to include(result.format)
+        end
+
+        it 'should have a non-zero height ' do
+          expect(result.height_px).to be > 0
+        end
+
+        it 'should have a non-zero width' do
+          expect(result.width_px).to be > 0
+        end
+
+        it 'should have a non-zero duration' do
+          expect(result.media_duration_seconds).to be > 0
+        end
+
+        it 'should have a non-nil frame rate' do
+          expect(result.frame_rate).not_to be_nil
+        end
+
+        it 'should have intrinsics' do
+          expect(result.intrinsics).not_to be_nil
+        end
       end
     end
 
@@ -51,12 +77,29 @@ describe FormatParser::MP4Parser do
       context "for #{path}" do
         let(:result) { subject.call(File.open(path, 'rb')) }
 
-        it('should not be nil') { expect(result).not_to be_nil }
-        it('should have audio nature') { expect(result.nature).to eq(:audio) }
-        it('should have MP4 audio content type') { expect(result.content_type).to eq('audio/mp4') }
-        it('should have MP4 audio format') { expect([:m4a, :m4b, :m4p, :m4r]).to include(result.format) }
-        it('should have a non-zero duration') { expect(result.media_duration_seconds).to be > 0 }
-        it('should have intrinsics') { expect(result.intrinsics).not_to be_nil }
+        it 'should not be nil' do
+          expect(result).not_to be_nil
+        end
+
+        it 'should have audio nature' do
+          expect(result.nature).to eq(:audio)
+        end
+
+        it 'should have MP4 audio content type' do
+          expect(result.content_type).to eq('audio/mp4')
+        end
+
+        it 'should have MP4 audio format' do
+          expect([:m4a, :m4b, :m4p, :m4r]).to include(result.format)
+        end
+
+        it 'should have a non-zero duration' do
+          expect(result.media_duration_seconds).to be > 0
+        end
+
+        it 'should have intrinsics' do
+          expect(result.intrinsics).not_to be_nil
+        end
       end
     end
 
@@ -64,7 +107,9 @@ describe FormatParser::MP4Parser do
       context "for #{path}" do
         let(:result) { subject.call(File.open(path, 'rb')) }
 
-        it('should be nil') { expect(result).to be_nil }
+        it 'should be nil' do
+          expect(result).to be_nil
+        end
       end
     end
 
@@ -74,10 +119,21 @@ describe FormatParser::MP4Parser do
         subject.call(File.open(path, 'rb'))
       end
 
-      it('should have the correct height') { expect(result.height_px).to eq(360) }
-      it('should have the correct width') { expect(result.width_px).to eq(640) }
-      it('should have the correct duration') { expect(result.media_duration_seconds.truncate(2)).to eq(9.36) }
-      it('should have the correct frame rate') { expect(result.frame_rate).to eq(30) }
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(360)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(640)
+      end
+
+      it 'should have the correct duration' do
+        expect(result.media_duration_seconds.truncate(2)).to eq(9.36)
+      end
+
+      it 'should have the correct frame rate' do
+        expect(result.frame_rate).to eq(30)
+      end
     end
 
     context "for a scaled MP4 video" do
@@ -86,8 +142,13 @@ describe FormatParser::MP4Parser do
         subject.call(File.open(path, 'rb'))
       end
 
-      it('should have the correct height') { expect(result.height_px).to eq(720) }
-      it('should have the correct width') { expect(result.width_px).to eq(1280) }
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(720)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(1280)
+      end
     end
 
     context "for a rotated MP4 video" do
@@ -96,8 +157,13 @@ describe FormatParser::MP4Parser do
         subject.call(File.open(path, 'rb'))
       end
 
-      it('should have the correct height') { expect(result.height_px).to eq(640) }
-      it('should have the correct width') { expect(result.width_px).to eq(360) }
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(640)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(360)
+      end
     end
 
     context "for a multi-track MP4 video" do
@@ -106,9 +172,17 @@ describe FormatParser::MP4Parser do
         subject.call(File.open(path, 'rb'))
       end
 
-      it('should have the correct height') { expect(result.height_px).to eq(1280) }
-      it('should have the correct width') { expect(result.width_px).to eq(1024) }
-      it('should have the correct frame rate') { expect(result.frame_rate).to eq(24) }
+      it 'should have the correct height' do
+        expect(result.height_px).to eq(1280)
+      end
+
+      it 'should have the correct width' do
+        expect(result.width_px).to eq(1024)
+      end
+
+      it 'should have the correct frame rate' do
+        expect(result.frame_rate).to eq(24)
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: format_parser
 version: !ruby/object:Gem::Version
-  version: 2.4.3
+  version: 2.4.5
 platform: ruby
 authors:
 - Noah Berman
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-27 00:00:00.000000000 Z
+date: 2023-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: exifr