rubyzip 1.1.7 → 1.2.4

data/test/data/notzippedruby.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 class NotZippedRuby
-  def returnTrue
+  def return_true
     true
   end
 end

data/test/data/path_traversal/Makefile

@@ -0,0 +1,10 @@
+# Based on 'relative2' in https://github.com/jwilk/path-traversal-samples,
+# but create the local `tmp` folder before adding the symlink. Otherwise
+# we may bail out before we get to trying to create the file.
+all: relative1.zip
+relative1.zip:
+	rm -f $(@)
+	mkdir -p -m 755 tmp/tmp
+	umask 022 && echo moo > moo
+	cd tmp && zip -X ../$(@) tmp tmp/../../moo
+	rm -rf tmp moo

data/test/data/path_traversal/jwilk/README.md

@@ -0,0 +1,5 @@
+# Path Traversal Samples
+
+Copied from https://github.com/jwilk/path-traversal-samples on 2018-08-26.
+
+License: MIT

data/test/data/path_traversal/tuzovakaoff/README.md

@@ -0,0 +1,3 @@
+# Path Traversal Samples
+
+Copied from https://github.com/tuzovakaoff/zip_path_traversal on 2018-08-25.

data/test/deflater_test.rb

@@ -8,15 +8,15 @@ class DeflaterTest < MiniTest::Test
   DEFAULT_COMP_FILE = 'test/data/generated/compressiontest_default_compression.bin'
   NO_COMP_FILE = 'test/data/generated/compressiontest_no_compression.bin'
 
-  def test_outputOperator
-    txt = load_file("test/data/file2.txt")
+  def test_output_operator
+    txt = load_file('test/data/file2.txt')
     deflate(txt, DEFLATER_TEST_FILE)
     inflatedTxt = inflate(DEFLATER_TEST_FILE)
     assert_equal(txt, inflatedTxt)
   end
 
   def test_default_compression
-    txt = load_file("test/data/file2.txt")
+    txt = load_file('test/data/file2.txt')
 
     Zip.default_compression = ::Zlib::BEST_COMPRESSION
     deflate(txt, BEST_COMP_FILE)
@@ -34,31 +34,29 @@ class DeflaterTest < MiniTest::Test
     assert(default < no)
   end
 
-
   private
+
   def load_file(fileName)
     txt = nil
-    File.open(fileName, "rb") { |f| txt = f.read }
+    File.open(fileName, 'rb') { |f| txt = f.read }
   end
 
   def deflate(data, fileName)
-    File.open(fileName, "wb") {
-        |file|
+    File.open(fileName, 'wb') do |file|
       deflater = ::Zip::Deflater.new(file)
       deflater << data
       deflater.finish
       assert_equal(deflater.size, data.size)
-      file << "trailing data for zlib with -MAX_WBITS"
-    }
+      file << 'trailing data for zlib with -MAX_WBITS'
+    end
   end
 
   def inflate(fileName)
     txt = nil
-    File.open(fileName, "rb") {
-        |file|
+    File.open(fileName, 'rb') do |file|
       inflater = ::Zip::Inflater.new(file)
       txt = inflater.sysread
-    }
+    end
   end
 
   def test_crc

data/test/encryption_test.rb

@@ -18,7 +18,7 @@ class EncryptionTest < MiniTest::Test
 
     @rand = [250, 143, 107, 13, 143, 22, 155, 75, 228, 150, 12]
     @output = ::Zip::DOSTime.stub(:now, ::Zip::DOSTime.new(2014, 12, 17, 15, 56, 24)) do
-      Random.stub(:rand, lambda { |range| @rand.shift }) do
+      Random.stub(:rand, ->(_range) { @rand.shift }) do
         Zip::OutputStream.write_buffer(::StringIO.new(''), Zip::TraditionalEncrypter.new('password')) do |zos|
           zos.put_next_entry('file1.txt')
           zos.write open(INPUT_FILE1).read
@@ -26,7 +26,7 @@ class EncryptionTest < MiniTest::Test
       end
     end
 
-    @output.unpack("C*").each_with_index do |c, i|
+    @output.unpack('C*').each_with_index do |c, i|
       assert_equal test_file[i].ord, c
     end
   end

data/test/entry_set_test.rb

@@ -2,12 +2,12 @@ require 'test_helper'
 
 class ZipEntrySetTest < MiniTest::Test
   ZIP_ENTRIES = [
-      ::Zip::Entry.new("zipfile.zip", "name1", "comment1"),
-      ::Zip::Entry.new("zipfile.zip", "name3", "comment1"),
-      ::Zip::Entry.new("zipfile.zip", "name2", "comment1"),
-      ::Zip::Entry.new("zipfile.zip", "name4", "comment1"),
-      ::Zip::Entry.new("zipfile.zip", "name5", "comment1"),
-      ::Zip::Entry.new("zipfile.zip", "name6", "comment1")
+    ::Zip::Entry.new('zipfile.zip', 'name1', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name3', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name2', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name4', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name5', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name6', 'comment1')
   ]
 
   def setup
@@ -20,20 +20,20 @@ class ZipEntrySetTest < MiniTest::Test
 
   def test_include
     assert(@zipEntrySet.include?(ZIP_ENTRIES.first))
-    assert(!@zipEntrySet.include?(::Zip::Entry.new("different.zip", "different", "aComment")))
+    assert(!@zipEntrySet.include?(::Zip::Entry.new('different.zip', 'different', 'aComment')))
   end
 
   def test_size
     assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
     assert_equal(ZIP_ENTRIES.size, @zipEntrySet.length)
-    @zipEntrySet << ::Zip::Entry.new("a", "b", "c")
+    @zipEntrySet << ::Zip::Entry.new('a', 'b', 'c')
     assert_equal(ZIP_ENTRIES.size + 1, @zipEntrySet.length)
   end
 
   def test_add
     zes = ::Zip::EntrySet.new
-    entry1 = ::Zip::Entry.new("zf.zip", "name1")
-    entry2 = ::Zip::Entry.new("zf.zip", "name2")
+    entry1 = ::Zip::Entry.new('zf.zip', 'name1')
+    entry2 = ::Zip::Entry.new('zf.zip', 'name2')
     zes << entry1
     assert(zes.include?(entry1))
     zes.push(entry2)
@@ -65,6 +65,20 @@ class ZipEntrySetTest < MiniTest::Test
     assert_equal(ZIP_ENTRIES, @zipEntrySet.entries)
   end
 
+  def test_find_entry
+    entries = [::Zip::Entry.new('zipfile.zip', 'MiXeDcAsEnAmE', 'comment1')]
+
+    ::Zip.case_insensitive_match = true
+    zipEntrySet = ::Zip::EntrySet.new(entries)
+    assert_equal(entries[0], zipEntrySet.find_entry('MiXeDcAsEnAmE'))
+    assert_equal(entries[0], zipEntrySet.find_entry('mixedcasename'))
+
+    ::Zip.case_insensitive_match = false
+    zipEntrySet = ::Zip::EntrySet.new(entries)
+    assert_equal(entries[0], zipEntrySet.find_entry('MiXeDcAsEnAmE'))
+    assert_nil(zipEntrySet.find_entry('mixedcasename'))
+  end
+
   def test_entries_with_sort
     ::Zip.sort_entries = true
     assert_equal(ZIP_ENTRIES.sort, @zipEntrySet.entries)
@@ -82,7 +96,7 @@ class ZipEntrySetTest < MiniTest::Test
   end
 
   def test_compound
-    newEntry = ::Zip::Entry.new("zf.zip", "new entry", "new entry's comment")
+    newEntry = ::Zip::Entry.new('zf.zip', 'new entry', "new entry's comment")
     assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
     @zipEntrySet << newEntry
     assert_equal(ZIP_ENTRIES.size + 1, @zipEntrySet.size)
@@ -97,19 +111,19 @@ class ZipEntrySetTest < MiniTest::Test
     assert_equal(@zipEntrySet, copy)
 
     # demonstrate that this is a deep copy
-    copy.entries[0].name = "a totally different name"
+    copy.entries[0].name = 'a totally different name'
     assert(@zipEntrySet != copy)
   end
 
   def test_parent
     entries = [
-        ::Zip::Entry.new("zf.zip", "a/"),
-        ::Zip::Entry.new("zf.zip", "a/b/"),
-        ::Zip::Entry.new("zf.zip", "a/b/c/")
+      ::Zip::Entry.new('zf.zip', 'a/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/c/')
     ]
     entrySet = ::Zip::EntrySet.new(entries)
 
-    assert_equal(nil, entrySet.parent(entries[0]))
+    assert_nil(entrySet.parent(entries[0]))
     assert_equal(entries[0], entrySet.parent(entries[1]))
     assert_equal(entries[1], entrySet.parent(entries[2]))
   end
@@ -122,17 +136,28 @@ class ZipEntrySetTest < MiniTest::Test
 
   def test_glob2
     entries = [
-        ::Zip::Entry.new("zf.zip", "a/"),
-        ::Zip::Entry.new("zf.zip", "a/b/b1"),
-        ::Zip::Entry.new("zf.zip", "a/b/c/"),
-        ::Zip::Entry.new("zf.zip", "a/b/c/c1")
+      ::Zip::Entry.new('zf.zip', 'a/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/b1'),
+      ::Zip::Entry.new('zf.zip', 'a/b/c/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/c/c1')
+    ]
+    entrySet = ::Zip::EntrySet.new(entries)
+
+    assert_equal(entries[0, 1], entrySet.glob('*'))
+    # assert_equal(entries[FIXME], entrySet.glob("**"))
+    # res = entrySet.glob('a*')
+    # assert_equal(entries.size, res.size)
+    # assert_equal(entrySet.map { |e| e.name }, res.map { |e| e.name })
+  end
+
+  def test_glob3
+    entries = [
+      ::Zip::Entry.new('zf.zip', 'a/a'),
+      ::Zip::Entry.new('zf.zip', 'a/b'),
+      ::Zip::Entry.new('zf.zip', 'a/c')
     ]
     entrySet = ::Zip::EntrySet.new(entries)
 
-    assert_equal(entries[0, 1], entrySet.glob("*"))
-#    assert_equal(entries[FIXME], entrySet.glob("**"))
-#    res = entrySet.glob('a*')
-#    assert_equal(entries.size, res.size)
-#    assert_equal(entrySet.map { |e| e.name }, res.map { |e| e.name })
+    assert_equal(entries[0, 2].sort, entrySet.glob('a/{a,b}').sort)
   end
 end

data/test/entry_test.rb

@@ -1,18 +1,9 @@
 require 'test_helper'
 
 class ZipEntryTest < MiniTest::Test
-  TEST_ZIPFILE = "someZipFile.zip"
-  TEST_COMMENT = "a comment"
-  TEST_COMPRESSED_SIZE = 1234
-  TEST_CRC = 325324
-  TEST_EXTRA = "Some data here"
-  TEST_COMPRESSIONMETHOD = ::Zip::Entry::DEFLATED
-  TEST_NAME = "entry name"
-  TEST_SIZE = 8432
-  TEST_ISDIRECTORY = false
-  TEST_TIME = Time.now
-
-  def test_constructorAndGetters
+  include ZipEntryData
+
+  def test_constructor_and_getters
     entry = ::Zip::Entry.new(TEST_ZIPFILE,
                              TEST_NAME,
                              TEST_COMMENT,
@@ -33,45 +24,45 @@ class ZipEntryTest < MiniTest::Test
     assert_equal(TEST_TIME, entry.time)
   end
 
-  def test_is_directoryAndIsFile
-    assert(::Zip::Entry.new(TEST_ZIPFILE, "hello").file?)
-    assert(!::Zip::Entry.new(TEST_ZIPFILE, "hello").directory?)
+  def test_is_directory_and_is_file
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'hello').file?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'hello').directory?)
 
-    assert(::Zip::Entry.new(TEST_ZIPFILE, "dir/hello").file?)
-    assert(!::Zip::Entry.new(TEST_ZIPFILE, "dir/hello").directory?)
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello').file?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello').directory?)
 
-    assert(::Zip::Entry.new(TEST_ZIPFILE, "hello/").directory?)
-    assert(!::Zip::Entry.new(TEST_ZIPFILE, "hello/").file?)
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'hello/').directory?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'hello/').file?)
 
-    assert(::Zip::Entry.new(TEST_ZIPFILE, "dir/hello/").directory?)
-    assert(!::Zip::Entry.new(TEST_ZIPFILE, "dir/hello/").file?)
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello/').directory?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello/').file?)
   end
 
   def test_equality
-    entry1 = ::Zip::Entry.new("file.zip", "name", "isNotCompared",
-                              "something extra", 123, 1234,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry2 = ::Zip::Entry.new("file.zip", "name", "isNotComparedXXX",
-                              "something extra", 123, 1234,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry3 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extra", 123, 1234,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry4 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extraXX", 123, 1234,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry5 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extraXX", 12, 1234,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry6 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extraXX", 12, 123,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry7 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extraXX", 12, 123,
-                              ::Zip::Entry::STORED, 10000)
-    entry8 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extraXX", 12, 123,
-                              ::Zip::Entry::STORED, 100000)
+    entry1 = ::Zip::Entry.new('file.zip', 'name', 'isNotCompared',
+                              'something extra', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry2 = ::Zip::Entry.new('file.zip', 'name', 'isNotComparedXXX',
+                              'something extra', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry3 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extra', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry4 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry5 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry6 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 123,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry7 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 123,
+                              ::Zip::Entry::STORED, 10_000)
+    entry8 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 123,
+                              ::Zip::Entry::STORED, 100_000)
 
     assert_equal(entry1, entry1)
     assert_equal(entry1, entry2)
@@ -83,51 +74,51 @@ class ZipEntryTest < MiniTest::Test
     assert(entry6 != entry7)
     assert(entry7 != entry8)
 
-    assert(entry7 != "hello")
+    assert(entry7 != 'hello')
     assert(entry7 != 12)
   end
 
   def test_compare
-    assert_equal(0, (::Zip::Entry.new("zf.zip", "a") <=> ::Zip::Entry.new("zf.zip", "a")))
-    assert_equal(1, (::Zip::Entry.new("zf.zip", "b") <=> ::Zip::Entry.new("zf.zip", "a")))
-    assert_equal(-1, (::Zip::Entry.new("zf.zip", "a") <=> ::Zip::Entry.new("zf.zip", "b")))
+    assert_equal(0, (::Zip::Entry.new('zf.zip', 'a') <=> ::Zip::Entry.new('zf.zip', 'a')))
+    assert_equal(1, (::Zip::Entry.new('zf.zip', 'b') <=> ::Zip::Entry.new('zf.zip', 'a')))
+    assert_equal(-1, (::Zip::Entry.new('zf.zip', 'a') <=> ::Zip::Entry.new('zf.zip', 'b')))
 
     entries = [
-        ::Zip::Entry.new("zf.zip", "5"),
-        ::Zip::Entry.new("zf.zip", "1"),
-        ::Zip::Entry.new("zf.zip", "3"),
-        ::Zip::Entry.new("zf.zip", "4"),
-        ::Zip::Entry.new("zf.zip", "0"),
-        ::Zip::Entry.new("zf.zip", "2")
+      ::Zip::Entry.new('zf.zip', '5'),
+      ::Zip::Entry.new('zf.zip', '1'),
+      ::Zip::Entry.new('zf.zip', '3'),
+      ::Zip::Entry.new('zf.zip', '4'),
+      ::Zip::Entry.new('zf.zip', '0'),
+      ::Zip::Entry.new('zf.zip', '2')
     ]
 
     entries.sort!
-    assert_equal("0", entries[0].to_s)
-    assert_equal("1", entries[1].to_s)
-    assert_equal("2", entries[2].to_s)
-    assert_equal("3", entries[3].to_s)
-    assert_equal("4", entries[4].to_s)
-    assert_equal("5", entries[5].to_s)
+    assert_equal('0', entries[0].to_s)
+    assert_equal('1', entries[1].to_s)
+    assert_equal('2', entries[2].to_s)
+    assert_equal('3', entries[3].to_s)
+    assert_equal('4', entries[4].to_s)
+    assert_equal('5', entries[5].to_s)
   end
 
-  def test_parentAsString
-    entry1 = ::Zip::Entry.new("zf.zip", "aa")
-    entry2 = ::Zip::Entry.new("zf.zip", "aa/")
-    entry3 = ::Zip::Entry.new("zf.zip", "aa/bb")
-    entry4 = ::Zip::Entry.new("zf.zip", "aa/bb/")
-    entry5 = ::Zip::Entry.new("zf.zip", "aa/bb/cc")
-    entry6 = ::Zip::Entry.new("zf.zip", "aa/bb/cc/")
-
-    assert_equal(nil, entry1.parent_as_string)
-    assert_equal(nil, entry2.parent_as_string)
-    assert_equal("aa/", entry3.parent_as_string)
-    assert_equal("aa/", entry4.parent_as_string)
-    assert_equal("aa/bb/", entry5.parent_as_string)
-    assert_equal("aa/bb/", entry6.parent_as_string)
+  def test_parent_as_string
+    entry1 = ::Zip::Entry.new('zf.zip', 'aa')
+    entry2 = ::Zip::Entry.new('zf.zip', 'aa/')
+    entry3 = ::Zip::Entry.new('zf.zip', 'aa/bb')
+    entry4 = ::Zip::Entry.new('zf.zip', 'aa/bb/')
+    entry5 = ::Zip::Entry.new('zf.zip', 'aa/bb/cc')
+    entry6 = ::Zip::Entry.new('zf.zip', 'aa/bb/cc/')
+
+    assert_nil(entry1.parent_as_string)
+    assert_nil(entry2.parent_as_string)
+    assert_equal('aa/', entry3.parent_as_string)
+    assert_equal('aa/', entry4.parent_as_string)
+    assert_equal('aa/bb/', entry5.parent_as_string)
+    assert_equal('aa/bb/', entry6.parent_as_string)
   end
 
   def test_entry_name_cannot_start_with_slash
-    assert_raises(::Zip::EntryNameError) { ::Zip::Entry.new("zf.zip", "/hej/der") }
+    assert_raises(::Zip::EntryNameError) { ::Zip::Entry.new('zf.zip', '/hej/der') }
   end
 
   def test_store_file_without_compression
@@ -139,27 +130,25 @@ class ZipEntryTest < MiniTest::Test
     end
 
     zipfile = Zip::File.open('/tmp/no_compress.zip', Zip::File::CREATE)
-    mimetype_entry = Zip::Entry.new(zipfile,                #@zipfile
-                                    'mimetype',             #@name
-                                    '',                     #@comment
-                                    '',                     #@extra
-                                    0,                      #@compressed_size
-                                    0,                      #@crc
-                                    Zip::Entry::STORED)     #@comppressed_method
+    mimetype_entry = Zip::Entry.new(zipfile,                # @zipfile
+                                    'mimetype',             # @name
+                                    '',                     # @comment
+                                    '',                     # @extra
+                                    0,                      # @compressed_size
+                                    0,                      # @crc
+                                    Zip::Entry::STORED)     # @comppressed_method
 
     zipfile.add(mimetype_entry, 'test/data/mimetype')
 
     files.each do |file|
-      zipfile.add(file.sub("test/data/globTest/", ''), file)
+      zipfile.add(file.sub('test/data/globTest/', ''), file)
     end
     zipfile.close
 
-    f= File.open('/tmp/no_compress.zip', 'rb')
+    f = File.open('/tmp/no_compress.zip', 'rb')
     first_100_bytes = f.read(100)
     f.close
 
     assert_match(/mimetypeapplication\/epub\+zip/, first_100_bytes)
   end
-
-
 end