rubyzip 2.1.0 → 3.6.0

data/lib/zip/crypto/decrypted_io.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Zip
+  class DecryptedIo # :nodoc:all
+    CHUNK_SIZE = 32_768
+
+    def initialize(io, decrypter, compressed_size)
+      @io = io
+      @decrypter = decrypter
+      @bytes_remaining = compressed_size
+      @buffer = +''.b
+      # Ensures that integrity is only checked once,
+      # even if read is called multiple times after the input has finished.
+      @integrity_verified = false
+    end
+
+    def read(maxlen = nil)
+      return (maxlen.nil? || maxlen.zero? ? '' : nil) if eof?
+
+      while maxlen.nil? || (@buffer.bytesize < maxlen)
+        break if input_finished?
+
+        @buffer << produce_input
+      end
+
+      if input_finished? && !@integrity_verified
+        @decrypter.check_integrity!(@io)
+        @integrity_verified = true
+      end
+
+      @buffer.slice!(0...(maxlen || @buffer.bytesize))
+    end
+
+    private
+
+    def eof?
+      @buffer.empty? && input_finished?
+    end
+
+    def input_finished?
+      !@bytes_remaining.positive?
+    end
+
+    def produce_input
+      chunk_size = [@bytes_remaining, CHUNK_SIZE].min
+      return '' unless chunk_size.positive?
+
+      @bytes_remaining -= chunk_size
+      @decrypter.decrypt(@io.read(chunk_size))
+    end
+  end
+end

data/lib/zip/crypto/encryption.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Zip
-  class Encrypter #:nodoc:all
+  class Encrypter # :nodoc:all
   end
 
-  class Decrypter
+  class Decrypter # :nodoc:all
   end
 end
 

data/lib/zip/crypto/null_encryption.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  module NullEncryption
+  module NullEncryption # :nodoc:
     def header_bytesize
       0
     end
@@ -9,7 +11,7 @@ module Zip
     end
   end
 
-  class NullEncrypter < Encrypter
+  class NullEncrypter < Encrypter # :nodoc:
     include NullEncryption
 
     def header(_mtime)
@@ -20,22 +22,12 @@ module Zip
       data
     end
 
-    def data_descriptor(_crc32, _compressed_size, _uncomprssed_size)
+    def data_descriptor(_crc32, _compressed_size, _uncompressed_size)
       ''
     end
 
     def reset!; end
   end
-
-  class NullDecrypter < Decrypter
-    include NullEncryption
-
-    def decrypt(data)
-      data
-    end
-
-    def reset!(_header); end
-  end
 end
 
 # Copyright (C) 2002, 2003 Thomas Sondergaard

data/lib/zip/crypto/traditional_encryption.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
 module Zip
-  module TraditionalEncryption
+  module TraditionalEncryption # :nodoc:
     def initialize(password)
       @password = password
       reset_keys!
@@ -24,9 +28,9 @@ module Zip
       end
     end
 
-    def update_keys(n)
-      @key0 = ~Zlib.crc32(n, ~@key0)
-      @key1 = ((@key1 + (@key0 & 0xff)) * 134_775_813 + 1) & 0xffffffff
+    def update_keys(num)
+      @key0 = ~Zlib.crc32(num, ~@key0)
+      @key1 = (((@key1 + (@key0 & 0xff)) * 134_775_813) + 1) & 0xffffffff
       @key2 = ~Zlib.crc32((@key1 >> 24).chr, ~@key2)
     end
 
@@ -36,13 +40,13 @@ module Zip
     end
   end
 
-  class TraditionalEncrypter < Encrypter
+  class TraditionalEncrypter < Encrypter # :nodoc:
     include TraditionalEncryption
 
     def header(mtime)
       [].tap do |header|
         (header_bytesize - 2).times do
-          header << Random.rand(0..255)
+          header << SecureRandom.rand(0..255)
         end
         header << (mtime.to_binary_dos_time & 0xff)
         header << (mtime.to_binary_dos_time >> 8)
@@ -53,8 +57,8 @@ module Zip
       data.unpack('C*').map { |x| encode x }.pack('C*')
     end
 
-    def data_descriptor(crc32, compressed_size, uncomprssed_size)
-      [0x08074b50, crc32, compressed_size, uncomprssed_size].pack('VVVV')
+    def data_descriptor(crc32, compressed_size, uncompressed_size)
+      [0x08074b50, crc32, compressed_size, uncompressed_size].pack('VVVV')
     end
 
     def reset!
@@ -63,14 +67,14 @@ module Zip
 
     private
 
-    def encode(n)
+    def encode(num)
       t = decrypt_byte
-      update_keys(n.chr)
-      t ^ n
+      update_keys(num.chr)
+      t ^ num
     end
   end
 
-  class TraditionalDecrypter < Decrypter
+  class TraditionalDecrypter < Decrypter # :nodoc:
     include TraditionalEncryption
 
     def decrypt(data)
@@ -84,12 +88,14 @@ module Zip
       end
     end
 
+    def check_integrity!(_io); end
+
     private
 
-    def decode(n)
-      n ^= decrypt_byte
-      update_keys(n.chr)
-      n
+    def decode(num)
+      num ^= decrypt_byte
+      update_keys(num.chr)
+      num
     end
   end
 end

data/lib/zip/decompressor.rb

@@ -1,9 +1,28 @@
+# frozen_string_literal: true
+
 module Zip
-  class Decompressor #:nodoc:all
+  class Decompressor # :nodoc:all
     CHUNK_SIZE = 32_768
-    def initialize(input_stream)
+
+    def self.decompressor_classes
+      @decompressor_classes ||= {}
+    end
+
+    def self.register(compression_method, decompressor_class)
+      decompressor_classes[compression_method] = decompressor_class
+    end
+
+    def self.find_by_compression_method(compression_method)
+      decompressor_classes[compression_method]
+    end
+
+    attr_reader :decompressed_size, :input_stream
+
+    def initialize(input_stream, decompressed_size = nil)
       super()
+
       @input_stream = input_stream
+      @decompressed_size = decompressed_size
     end
   end
 end

data/lib/zip/deflater.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class Deflater < Compressor #:nodoc:all
+  class Deflater < Compressor # :nodoc:all
     def initialize(output_stream, level = Zip.default_compression, encrypter = NullEncrypter.new)
       super()
       @output_stream = output_stream
@@ -13,16 +15,18 @@ module Zip
       val   = data.to_s
       @crc  = Zlib.crc32(val, @crc)
       @size += val.bytesize
-      buffer = @zlib_deflater.deflate(data)
-      if buffer.empty?
-        @output_stream
-      else
-        @output_stream << @encrypter.encrypt(buffer)
-      end
+
+      # When JRuby#3962 is fixed, we can remove the flushing parameter here.
+      buffer = @zlib_deflater.deflate(data, Zip::ZLIB_FLUSHING_STRATEGY)
+      return @output_stream if buffer.empty?
+
+      @output_stream << @encrypter.encrypt(buffer)
     end
 
     def finish
-      @output_stream << @encrypter.encrypt(@zlib_deflater.finish) until @zlib_deflater.finished?
+      buffer = @zlib_deflater.finish
+      @output_stream << @encrypter.encrypt(buffer) unless buffer.empty?
+      @zlib_deflater.close
     end
 
     attr_reader :size, :crc

data/lib/zip/dirtyable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Zip
+  module Dirtyable # :nodoc:all
+    def initialize(dirty_on_create: true)
+      @dirty = dirty_on_create
+    end
+
+    def dirty?
+      @dirty
+    end
+
+    module ClassMethods # :nodoc:
+      def mark_dirty(*symbols) # :nodoc:
+        # Move the original method and call it after we've set the dirty flag.
+        symbols.each do |symbol|
+          orig_name = "orig_#{symbol}"
+          alias_method orig_name, symbol
+
+          define_method(symbol) do |param|
+            @dirty = true
+            send(orig_name, param)
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/zip/dos_time.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+
 module Zip
-  class DOSTime < Time #:nodoc:all
+  class DOSTime < Time # :nodoc:all
     # MS-DOS File Date and Time format as used in Interrupt 21H Function 57H:
 
     # Register CX, the Time:
@@ -12,21 +16,55 @@ module Zip
     # bits 5-8 month (1-12)
     # bits 9-15 year (four digit year minus 1980)
 
+    # The MS-DOS date field is seven bits of "year minus 1980", so only
+    # 1980-01-01 00:00:00 through 2107-12-31 23:59:58 can be represented.
+    # Times outside that are clamped rather than allowed to wrap: the real
+    # time is still carried in the universal time (UT) extra field, but the
+    # DOS fields have to stay in range for readers that only look at those.
+    DOS_EPOCH_YEAR = 1980
+    DOS_MAX_YEAR = 2107
+    DOS_MIN_DATE = 0x0021 # 1980-01-01
+    DOS_MAX_DATE = 0xff9f # 2107-12-31
+    DOS_MIN_TIME = 0x0000 # 00:00:00
+    DOS_MAX_TIME = 0xbf7d # 23:59:58
+
+    attr_writer :absolute_time # :nodoc:
+
+    def absolute_time?
+      # If absolute time is not set, we can assume it is an absolute time
+      # because times do have timezone information by default.
+      @absolute_time.nil? || @absolute_time
+    end
+
     def to_binary_dos_time
+      return DOS_MIN_TIME if year < DOS_EPOCH_YEAR
+      return DOS_MAX_TIME if year > DOS_MAX_YEAR
+
       (sec / 2) +
         (min << 5) +
         (hour << 11)
     end
 
     def to_binary_dos_date
+      return DOS_MIN_DATE if year < DOS_EPOCH_YEAR
+      return DOS_MAX_DATE if year > DOS_MAX_YEAR
+
       day +
         (month << 5) +
-        ((year - 1980) << 9)
+        ((year - DOS_EPOCH_YEAR) << 9)
     end
 
-    # Dos time is only stored with two seconds accuracy
-    def dos_equals(other)
-      to_i / 2 == other.to_i / 2
+    # Deprecated. Remove for version 4.
+    def dos_equals(other) # rubocop:disable Naming/PredicateMethod
+      warn 'Zip::DOSTime#dos_equals is deprecated. Use `==` instead.'
+      self == other
+    end
+
+    # Dos time is only stored with two seconds accuracy.
+    def <=>(other)
+      return unless other.kind_of?(Time)
+
+      (to_i / 2) <=> (other.to_i / 2)
     end
 
     # Create a DOSTime instance from a vanilla Time instance.
@@ -34,16 +72,43 @@ module Zip
       local(time.year, time.month, time.day, time.hour, time.min, time.sec)
     end
 
-    def self.parse_binary_dos_format(binaryDosDate, binaryDosTime)
-      second = 2 * (0b11111 & binaryDosTime)
-      minute = (0b11111100000 & binaryDosTime) >> 5
-      hour   = (0b1111100000000000 & binaryDosTime) >> 11
-      day    = (0b11111 & binaryDosDate)
-      month  = (0b111100000 & binaryDosDate) >> 5
-      year   = ((0b1111111000000000 & binaryDosDate) >> 9) + 1980
-      begin
-        local(year, month, day, hour, minute, second)
+    def self.parse_binary_dos_format(bin_dos_date, bin_dos_time)
+      second = 2 * (0b11111 & bin_dos_time)
+      minute = (0b11111100000 & bin_dos_time) >> 5
+      hour   = (0b1111100000000000 & bin_dos_time) >> 11
+      day    = (0b11111 & bin_dos_date)
+      month  = (0b111100000 & bin_dos_date) >> 5
+      year   = ((0b1111111000000000 & bin_dos_date) >> 9) + 1980
+
+      time = local(year, month, day, hour, minute, second)
+      time.absolute_time = false
+      time
+    end
+
+    if defined? JRUBY_VERSION && Gem::Version.new(JRUBY_VERSION) < '9.2.18.0'
+      module JRubyCMP # :nodoc:
+        def ==(other)
+          (self <=> other).zero?
+        end
+
+        def <(other)
+          (self <=> other).negative?
+        end
+
+        def <=(other)
+          (self <=> other) <= 0
+        end
+
+        def >(other)
+          (self <=> other).positive?
+        end
+
+        def >=(other)
+          (self <=> other) >= 0
+        end
       end
+
+      include JRubyCMP
     end
   end
 end