rubyzip 1.1.6 → 1.1.7

data/lib/zip/extra_field/ntfs.rb

@@ -0,0 +1,92 @@
+module Zip
+  # PKWARE NTFS Extra Field (0x000a)
+  # Only Tag 0x0001 is supported
+  class ExtraField::NTFS < ExtraField::Generic
+    HEADER_ID = [0x000A].pack('v')
+    register_map
+
+    WINDOWS_TICK = 10000000.0
+    SEC_TO_UNIX_EPOCH = 11644473600
+
+    def initialize(binstr = nil)
+      @ctime = nil
+      @mtime = nil
+      @atime = nil
+      binstr and merge(binstr)
+    end
+
+    attr_accessor :atime, :ctime, :mtime
+
+    def merge(binstr)
+      return if binstr.empty?
+      size, content = initial_parse(binstr)
+      (size && content) or return
+
+      content = content[4..-1]
+      tags = parse_tags(content)
+
+      tag1 = tags[1]
+      if tag1
+        ntfs_mtime, ntfs_atime, ntfs_ctime = tag1.unpack("Q<Q<Q<")
+        ntfs_mtime and @mtime ||= from_ntfs_time(ntfs_mtime)
+        ntfs_atime and @atime ||= from_ntfs_time(ntfs_atime)
+        ntfs_ctime and @ctime ||= from_ntfs_time(ntfs_ctime)
+      end
+    end
+
+    def ==(other)
+      @mtime == other.mtime &&
+        @atime == other.atime &&
+        @ctime == other.ctime
+    end
+
+    # Info-ZIP note states this extra field is stored at local header
+    def pack_for_local
+      pack_for_c_dir
+    end
+
+    # But 7-zip for Windows only stores at central dir
+    def pack_for_c_dir
+      # reserved 0 and tag 1
+      s = [0, 1].pack("Vv")
+
+      tag1 = ''.force_encoding(Encoding::BINARY)
+      if @mtime
+        tag1 << [to_ntfs_time(@mtime)].pack('Q<')
+        if @atime
+          tag1 << [to_ntfs_time(@atime)].pack('Q<')
+          if @ctime
+            tag1 << [to_ntfs_time(@ctime)].pack('Q<')
+          end
+        end
+      end
+      s << [tag1.bytesize].pack('v') << tag1
+      s
+    end
+
+    private
+    def parse_tags(content)
+      return {} if content.nil?
+      tags = {}
+      i = 0
+      while i < content.bytesize do
+        tag, size = content[i, 4].unpack('vv')
+        i += 4
+        break unless tag && size
+        value = content[i, size]
+        i += size
+        tags[tag] = value
+      end
+
+      tags
+    end
+
+    def from_ntfs_time(ntfs_time)
+      ::Zip::DOSTime.at(ntfs_time / WINDOWS_TICK - SEC_TO_UNIX_EPOCH)
+    end
+
+    def to_ntfs_time(time)
+      ((time.to_f + SEC_TO_UNIX_EPOCH) * WINDOWS_TICK).to_i
+    end
+  end
+end

data/lib/zip/file.rb

@@ -121,11 +121,18 @@ module Zip
         if io.is_a?(::String)
           require 'stringio'
           io = ::StringIO.new(io)
+        elsif io.is_a?(IO)
+          # https://github.com/rubyzip/rubyzip/issues/119
+          io.binmode
         end
         zf = ::Zip::File.new(io, true, true, options)
         zf.read_from_stream(io)
         yield zf
-        zf.write_buffer(io)
+        begin
+          zf.write_buffer(io)
+        rescue IOError => e
+          raise unless e.message == "not opened for writing"
+        end
       end
 
       # Iterates over the contents of the ZipFile. This is more efficient
@@ -403,6 +410,7 @@ module Zip
     def on_success_replace
       tmpfile      = get_tempfile
       tmp_filename = tmpfile.path
+      ObjectSpace.undefine_finalizer(tmpfile)
       tmpfile.close
       if yield tmp_filename
         ::File.rename(tmp_filename, self.name)
@@ -410,6 +418,8 @@ module Zip
           ::File.chmod(@exist_file_perms, self.name)
         end
       end
+    ensure
+      tmpfile.unlink if tmpfile
     end
 
     def get_tempfile

data/lib/zip/filesystem.rb

@@ -320,6 +320,8 @@ module Zip
         e = get_entry(fileName)
         if e.extra.member? "UniversalTime"
           e.extra["UniversalTime"].atime
+        elsif e.extra.member? "NTFS"
+          e.extra["NTFS"].atime
         else
           nil
         end
@@ -329,6 +331,8 @@ module Zip
         e = get_entry(fileName)
         if e.extra.member? "UniversalTime"
           e.extra["UniversalTime"].ctime
+        elsif e.extra.member? "NTFS"
+          e.extra["NTFS"].ctime
         else
           nil
         end

data/lib/zip/inflater.rb

@@ -1,10 +1,11 @@
 module Zip
   class Inflater < Decompressor #:nodoc:all
-    def initialize(input_stream)
-      super
+    def initialize(input_stream, decrypter = NullDecrypter.new)
+      super(input_stream)
       @zlib_inflater           = ::Zlib::Inflate.new(-Zlib::MAX_WBITS)
       @output_buffer           = ''
       @has_returned_empty_string = false
+      @decrypter               = decrypter
     end
 
     def sysread(number_of_bytes = nil, buf = '')
@@ -40,7 +41,7 @@ module Zip
     def internal_produce_input(buf = '')
       retried = 0
       begin
-        @zlib_inflater.inflate(@input_stream.read(Decompressor::CHUNK_SIZE, buf))
+        @zlib_inflater.inflate(@decrypter.decrypt(@input_stream.read(Decompressor::CHUNK_SIZE, buf)))
       rescue Zlib::BufError
         raise if retried >= 5 # how many times should we retry?
         retried += 1

data/lib/zip/input_stream.rb

@@ -47,10 +47,11 @@ module Zip
     #
     # @param context [String||IO||StringIO] file path or IO/StringIO object
     # @param offset [Integer] offset in the IO/StringIO
-    def initialize(context, offset = 0)
+    def initialize(context, offset = 0, decrypter = nil)
       super()
       @archive_io = get_io(context, offset)
       @decompressor  = ::Zip::NullDecompressor
+      @decrypter     = decrypter || ::Zip::NullDecrypter.new
       @current_entry = nil
     end
 
@@ -91,8 +92,8 @@ module Zip
       # Same as #initialize but if a block is passed the opened
       # stream is passed to the block and closed when the block
       # returns.
-      def open(filename_or_io, offset = 0)
-        zio = self.new(filename_or_io, offset)
+      def open(filename_or_io, offset = 0, decrypter = nil)
+        zio = self.new(filename_or_io, offset, decrypter)
         return zio unless block_given?
         begin
           yield zio
@@ -124,6 +125,9 @@ module Zip
 
     def open_entry
       @current_entry = ::Zip::Entry.read_local_entry(@archive_io)
+      if @current_entry and @current_entry.gp_flags & 1 == 1 and @decrypter.is_a? NullEncrypter
+        raise Error, 'password required to decode zip file'
+      end
       @decompressor  = get_decompressor
       flush
       @current_entry
@@ -136,7 +140,9 @@ module Zip
       when @current_entry.compression_method == ::Zip::Entry::STORED
         ::Zip::PassThruDecompressor.new(@archive_io, @current_entry.size)
       when @current_entry.compression_method == ::Zip::Entry::DEFLATED
-        ::Zip::Inflater.new(@archive_io)
+        header = @archive_io.read(@decrypter.header_bytesize)
+        @decrypter.reset!(header)
+        ::Zip::Inflater.new(@archive_io, @decrypter)
       else
         raise ::Zip::CompressionMethodError,
               "Unsupported compression method #{@current_entry.compression_method}"

data/lib/zip/output_stream.rb

@@ -24,12 +24,12 @@ module Zip
 
     # Opens the indicated zip file. If a file with that name already
     # exists it will be overwritten.
-    def initialize(file_name, stream=false)
+    def initialize(file_name, stream=false, encrypter=nil)
       super()
       @file_name = file_name
       @output_stream = if stream
                          iostream = @file_name.dup
-                         iostream.reopen
+                         iostream.reopen(@file_name)
                          iostream.rewind
                          iostream
                        else
@@ -37,6 +37,7 @@ module Zip
                        end
       @entry_set = ::Zip::EntrySet.new
       @compressor = ::Zip::NullCompressor.instance
+      @encrypter = encrypter || ::Zip::NullEncrypter.new
       @closed = false
       @current_entry = nil
       @comment = nil
@@ -46,17 +47,17 @@ module Zip
     # stream is passed to the block and closed when the block
     # returns.
     class << self
-      def open(file_name)
+      def open(file_name, encrypter = nil)
         return new(file_name) unless block_given?
-        zos = new(file_name)
+        zos = new(file_name, false, encrypter)
         yield zos
       ensure
         zos.close if zos
       end
 
       # Same as #open but writes to a filestream instead
-      def write_buffer(io = ::StringIO.new(''))
-        zos = new(io, true)
+      def write_buffer(io = ::StringIO.new(''), encrypter = nil)
+        zos = new(io, true, encrypter)
         yield zos
         zos.close_buffer
       end
@@ -122,10 +123,13 @@ module Zip
 
     def finalize_current_entry
       return unless @current_entry
+      @output_stream << @encrypter.header(@current_entry.mtime)
       finish
       @current_entry.compressed_size = @output_stream.tell - @current_entry.local_header_offset - @current_entry.calculate_local_header_size
       @current_entry.size = @compressor.size
       @current_entry.crc = @compressor.crc
+      @output_stream << @encrypter.data_descriptor(@current_entry.crc, @current_entry.compressed_size, @current_entry.size)
+      @current_entry.gp_flags |= @encrypter.gp_flags
       @current_entry = nil
       @compressor = ::Zip::NullCompressor.instance
     end
@@ -134,13 +138,14 @@ module Zip
       finalize_current_entry
       @entry_set << entry
       entry.write_local_entry(@output_stream)
+      @encrypter.reset!
       @compressor = get_compressor(entry, level)
     end
 
     def get_compressor(entry, level)
       case entry.compression_method
       when Entry::DEFLATED then
-        ::Zip::Deflater.new(@output_stream, level)
+        ::Zip::Deflater.new(@output_stream, level, @encrypter)
       when Entry::STORED then
         ::Zip::PassThruCompressor.new(@output_stream)
       else

data/lib/zip/version.rb

@@ -1,3 +1,3 @@
 module Zip
-  VERSION = '1.1.6'
+  VERSION = '1.1.7'
 end

data/test/basic_zip_file_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class BasicZipFileTest < MiniTest::Unit::TestCase
+class BasicZipFileTest < MiniTest::Test
   include AssertEntry
 
   def setup

data/test/central_directory_entry_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ZipCentralDirectoryEntryTest < MiniTest::Unit::TestCase
+class ZipCentralDirectoryEntryTest < MiniTest::Test
 
   def test_read_from_stream
     File.open("test/data/testDirectory.bin", "rb") {

data/test/central_directory_test.rb

@@ -1,6 +1,10 @@
 require 'test_helper'
 
-class ZipCentralDirectoryTest < MiniTest::Unit::TestCase
+class ZipCentralDirectoryTest < MiniTest::Test
+
+  def teardown
+    ::Zip.reset!
+  end
 
   def test_read_from_stream
     ::File.open(TestZipFile::TEST_ZIP2.zip_name, "rb") {

data/test/crypto/null_encryption_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class NullEncrypterTest < MiniTest::Test
+  def setup
+    @encrypter = ::Zip::NullEncrypter.new
+  end
+  
+  def test_header_bytesize
+    assert_equal 0, @encrypter.header_bytesize
+  end
+
+  def test_gp_flags
+    assert_equal 0, @encrypter.gp_flags
+  end
+
+  def test_header
+    assert_empty @encrypter.header(nil)
+  end
+
+  def test_encrypt
+    [nil, '', 'a' * 10, 0xffffffff].each do |data|
+      assert_equal data, @encrypter.encrypt(data)
+    end
+  end
+
+  def test_reset!
+    assert_respond_to @encrypter, :reset!
+  end
+end
+
+class NullDecrypterTest < MiniTest::Test
+  def setup
+    @decrypter = ::Zip::NullDecrypter.new
+  end
+  
+  def test_header_bytesize
+    assert_equal 0, @decrypter.header_bytesize
+  end
+
+  def test_gp_flags
+    assert_equal 0, @decrypter.gp_flags
+  end
+
+  def test_decrypt
+    [nil, '', 'a' * 10, 0xffffffff].each do |data|
+      assert_equal data, @decrypter.decrypt(data)
+    end
+  end
+
+  def test_reset!
+    assert_respond_to @decrypter, :reset!
+  end
+end

data/test/crypto/traditional_encryption_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+class TraditionalEncrypterTest < MiniTest::Test
+  def setup
+    @mtime = ::Zip::DOSTime.new(2014, 12, 17, 15, 56, 24)
+    @encrypter = ::Zip::TraditionalEncrypter.new('password')
+  end
+
+  def test_header_bytesize
+    assert_equal 12, @encrypter.header_bytesize
+  end
+
+  def test_gp_flags
+    assert_equal 9, @encrypter.gp_flags
+  end
+
+  def test_header
+    @encrypter.reset!
+    exepected = [239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*")
+    Random.stub(:rand, 1) do
+      assert_equal exepected, @encrypter.header(@mtime)
+    end
+  end
+
+  def test_encrypt
+    @encrypter.reset!
+    Random.stub(:rand, 1) { @encrypter.header(@mtime) }
+    assert_raises(NoMethodError) { @encrypter.encrypt(nil) }
+    assert_raises(NoMethodError) { @encrypter.encrypt(1) }
+    assert_equal '', @encrypter.encrypt('')
+    assert_equal [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].pack("C*"), @encrypter.encrypt('a' * 10)
+  end
+
+  def test_reset!
+    @encrypter.reset!
+    Random.stub(:rand, 1) { @encrypter.header(@mtime) }
+    [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
+      assert_equal c, @encrypter.encrypt('a')
+    end
+    assert_equal 56.chr, @encrypter.encrypt('a')
+    @encrypter.reset!
+    Random.stub(:rand, 1) { @encrypter.header(@mtime) }
+    [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
+      assert_equal c, @encrypter.encrypt('a')
+    end
+  end
+end
+
+class TraditionalDecrypterTest < MiniTest::Test
+  def setup
+    @decrypter = ::Zip::TraditionalDecrypter.new('password')
+  end
+
+  def test_header_bytesize
+    assert_equal 12, @decrypter.header_bytesize
+  end
+
+  def test_gp_flags
+    assert_equal 9, @decrypter.gp_flags
+  end
+
+  def test_decrypt
+    @decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*"))
+    [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
+      assert_equal 'a', @decrypter.decrypt(c)
+    end
+  end
+
+  def test_reset!
+    @decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*"))
+    [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
+      assert_equal 'a', @decrypter.decrypt(c)
+    end
+    assert_equal 91.chr, @decrypter.decrypt(2.chr)
+    @decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*"))
+    [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
+      assert_equal 'a', @decrypter.decrypt(c)
+    end
+  end
+end