rubyzip 3.0.2 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4afc6447f838d0d2edc82bb44ab842a5c45f50bd47d453aae1a7b487c9dcbee
-  data.tar.gz: 776833d664351c8e0323826263d16b2b11486fee80a7ceda1a8385d05dd2a38e
+  metadata.gz: 67852d915e2ec168efb617d7577ac60196bf7433b3c2800981a14c5a43b939c5
+  data.tar.gz: '039b39e7e9e7f46e056da4d0070554eba081e26a4dd99e3dd47d76428628d29f'
 SHA512:
-  metadata.gz: b52059d2cfba5c05959bb347383d4bfe79c8f3c0f945cba64362462267c750f0e16e13f63fbf272b2cf0935173678b876164c3993ddae85fb89dec726afea940
-  data.tar.gz: 83a932fbadf6fbafa0a1e64434f0b2a2b7f58fb56d9015350eae217430f9afaf5492254a56de9be124bdf9676a8a5aa373515c996ce2f74966aceb87b72472d1
+  metadata.gz: ba24363c26265acbd295289685d5baa4d351a913d98de67064171c35f0055f04ac34b2e6db384af248e124b12abc505bac558205eadb2975d3d4da59178b9a54
+  data.tar.gz: b654167d21076c70ea58b6a185f4be83a6ef172d208bf4f8a8928ac82aa909773b20df462870dc833b1182f669334e18fd7283e23cf4040b770faea1a49d1e6a

data/Changelog.md

@@ -1,3 +1,52 @@
+# 3.2.2 (2025-11-02)
+
+- Fix reading EOCDs when header signatures are in an Entry payload. [#656](https://github.com/rubyzip/rubyzip/issues/656)
+
+Tooling/internal:
+
+- Stop using macos-13 runners in GitHub Actions.
+- Update YJIT GitHub Actions runners.
+
+# 3.2.1 (2025-10-24)
+
+- Fix `Entry#gather_fileinfo_from_srcpath` error messages. [#654](https://github.com/rubyzip/rubyzip/issues/654)
+
+Tooling/internal:
+
+- Add some simple benchmarks for reading the cdir.
+
+# 3.2.0 (2025-10-14)
+
+- Add option to suppress extra fields. [#653](https://github.com/rubyzip/rubyzip/pull/653) (fixes [#34](https://github.com/rubyzip/rubyzip/issues/34), [#398](https://github.com/rubyzip/rubyzip/issues/398) and [#648](https://github.com/rubyzip/rubyzip/issues/648))
+
+Tooling/internal:
+
+- Entry: clean up reading and writing the Central Directory headers.
+- Improve Zip64 tests for `OutputStream`.
+- Extra fields: use symbols as indices as opposed to strings.
+- Ensure that `Unknown` extra field has a superclass.
+
+# 3.1.1 (2025-09-26)
+
+- Improve the IO pipeline when decompressing. [#649](https://github.com/rubyzip/rubyzip/pull/649) (which also fixes [#647](https://github.com/rubyzip/rubyzip/issues/647))
+
+Tooling/internal:
+
+- Improve the `DecryptedIo` class with various updates and optimizations.
+- Remove the `NullDecrypter` class.
+- Properly convert the test suite to use minitest.
+- Move all test helper code into separate files.
+- Updates to the Actions CI, including new OS versions.
+- Update rubocop versions and fix resultant cop failures. [#646](https://github.com/rubyzip/rubyzip/pull/646)
+
+# 3.1.0 (2025-09-06)
+
+- Support AES decryption. [#579](https://github.com/rubyzip/rubyzip/pull/579) and [#645](https://github.com/rubyzip/rubyzip/pull/645)
+
+Tooling/internal:
+
+- Add various useful zip specification documents to the repo for ease of finding them in the future. These are not included in the gem release.
+
 # 3.0.2 (2025-08-21)
 
 - Fix `InputStream#sysread` to handle frozen string literals. [#643](https://github.com/rubyzip/rubyzip/pull/643)

data/README.md

@@ -3,7 +3,8 @@
 [![Gem Version](https://badge.fury.io/rb/rubyzip.svg)](http://badge.fury.io/rb/rubyzip)
 [![Tests](https://github.com/rubyzip/rubyzip/actions/workflows/tests.yml/badge.svg)](https://github.com/rubyzip/rubyzip/actions/workflows/tests.yml)
 [![Linter](https://github.com/rubyzip/rubyzip/actions/workflows/lint.yml/badge.svg)](https://github.com/rubyzip/rubyzip/actions/workflows/lint.yml)
-[![Code Climate](https://codeclimate.com/github/rubyzip/rubyzip.svg)](https://codeclimate.com/github/rubyzip/rubyzip)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop)
+[![Maintainability](https://qlty.sh/gh/rubyzip/projects/rubyzip/maintainability.svg)](https://qlty.sh/gh/rubyzip/projects/rubyzip)
 [![Coverage Status](https://img.shields.io/coveralls/rubyzip/rubyzip.svg)](https://coveralls.io/r/rubyzip/rubyzip?branch=master)
 
 Rubyzip is a ruby library for reading and writing zip files.
@@ -66,6 +67,48 @@ Zip::File.open(zipfile_name, create: true) do |zipfile|
 end
 ```
 
+### Creating a Zip file with `Zip::OutputStream`
+
+```ruby
+require 'rubygems'
+require 'zip'
+
+Zip::OutputStream.open('archive.zip') do |zos|
+  # Quick.
+  zos.put_next_entry('greeting.txt')
+  zos << 'Hello, World!'
+
+  # More control.
+  # You MUST NOT make any calls on your `Entry` after calling `put_next_entry`.
+  entry = Zip::Entry.new(nil, 'parting.txt')
+  entry.atime = Time.now
+  zos.put_next_entry(entry)
+  zos.write('TTFN')
+end
+```
+
+You can generate a Zip archive in memory using `Zip::OutputStream.write_buffer`.
+
+### Suppressing extra fields
+
+If you wish to suppress extra fields from being added to your entries, you can do so by passing the `suppress_extra_fields` parameter to any of the archive opening calls within `Zip::File` or `Zip::OutputStream`, e.g.:
+
+```ruby
+# Suppress all extra fields.
+Zip::File.open('archive.zip', create: true, suppress_extra_fields: true)
+Zip::OutputStream.open('archive.zip', suppress_extra_fields: true)
+
+# Suppress an individual extra field.
+Zip::File.open('archive.zip', create: true, suppress_extra_fields: :zip64)
+Zip::OutputStream.open('archive.zip', suppress_extra_fields: :zip64)
+
+# Suppress multiple extra fields.
+Zip::File.open('archive.zip', create: true, suppress_extra_fields: [:ntfs, :zip64])
+Zip::OutputStream.open('archive.zip', suppress_extra_fields: [:ntfs, :zip64])
+```
+
+Note that there are some extra fields that cannot be suppressed at all (e.g. `:aes`), and some which will only be suppressed if it is safe to do so (e.g. `:zip64`).
+
 ### Zipping a directory recursively
 
 Copy from [here](https://github.com/rubyzip/rubyzip/blob/9d891f7353e66052283562d3e252fe380bb4b199/samples/example_recursive.rb)
@@ -179,7 +222,7 @@ Zip::File.open('foo.zip') do |zip_file|
 end
 ```
 
-### Notes on `Zip::InputStream`
+### Reading a Zip file with `Zip::InputStream`
 
 `Zip::InputStream` can be used for faster reading of zip file content because it does not read the Central directory up front.
 
@@ -189,23 +232,23 @@ There is one exception where it can not work however, and this is if the file do
 
 If `Zip::InputStream` finds such an entry in the zip archive it will raise an exception (`Zip::StreamingError`).
 
-`Zip::InputStream` is not designed to be used for random access in a zip file. When performing any operations on an entry that you are accessing via `Zip::InputStream.get_next_entry` then you should complete any such operations before the next call to `get_next_entry`.
+`Zip::InputStream` is not designed to be used for random access in a zip file. When performing any operations on an entry that you are accessing via `Zip::InputStream#get_next_entry` then you should complete any such operations before the next call to `get_next_entry`.
 
 ```ruby
-zip_stream = Zip::InputStream.new(File.open('file.zip'))
-
-while entry = zip_stream.get_next_entry
-  # All required operations on `entry` go here.
-end
+Zip::InputStream.open('file.zip') do |zip_stream|
+  while entry = zip_stream.get_next_entry
+    # All required operations on `entry` go here.
+  end
+end # The `InputStream` is closed at the end of the block.
 ```
 
 Any attempt to move about in a zip file opened with `Zip::InputStream` could result in the incorrect entry being accessed and/or Zlib buffer errors. If you need random access in a zip file, use `Zip::File`.
 
-### Password Protection (Experimental)
+### Password Protection (experimental)
 
-Rubyzip supports reading/writing zip files with traditional zip encryption (a.k.a. "ZipCrypto"). AES encryption is not yet supported. It can be used with buffer streams, e.g.:
+Rubyzip supports reading zip files with AES encryption (version 3.1 and later), and reading and writing zip files with traditional zip encryption (a.k.a. "ZipCrypto"). Encryption is currently only available with the stream API, with either files or buffers, e.g.:
 
-#### Version 2.x
+#### Version 2.x (ZipCrypto only)
 
 ```ruby
 # Writing.
@@ -224,9 +267,17 @@ Zip::InputStream.open(buffer, 0, dec) do |input|
 end
 ```
 
-#### Version 3.x
+#### Version 3.x (AES reading and ZipCrypto read/write)
 
 ```ruby
+# Reading AES, version 3.1 and later.
+dec = Zip::AESDecrypter.new('password', Zip::AESEncryption::STRENGTH_256_BIT)
+Zip::InputStream.open('aes-encrypted-file.zip', decrypter: dec) do |input|
+  entry = input.get_next_entry
+  puts "Contents of '#{entry.name}':"
+  puts input.read
+end
+
 # Writing.
 enc = Zip::TraditionalEncrypter.new('password')
 buffer = Zip::OutputStream.write_buffer(encrypter: enc) do |output|
@@ -243,7 +294,7 @@ Zip::InputStream.open(buffer, decrypter: dec) do |input|
 end
 ```
 
-_This is an experimental feature and the interface for encryption may change in future versions._
+_This is an evolving feature and the interface for encryption may change in future versions._
 
 ## Known issues
 

data/Rakefile

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
 require 'bundler/gem_tasks'
-require 'rake/testtask'
+require 'minitest/test_task'
 require 'rdoc/task'
 require 'rubocop/rake_task'
 
 task default: :test
 
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib'
-  test.libs << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
+Minitest::TestTask.create do |test|
+  test.framework = 'require "simplecov"'
+  test.test_globs = 'test/**/*_test.rb'
 end
 
 RDoc::Task.new do |rdoc|

data/lib/zip/central_directory.rb

@@ -39,9 +39,11 @@ module Zip
       read_central_directory_entries(io)
     end
 
-    def write_to_stream(io) # :nodoc:
+    def write_to_stream(io, suppress_extra_fields: false) # :nodoc:
       cdir_offset = io.tell
-      @entry_set.each { |entry| entry.write_c_dir_entry(io) }
+      @entry_set.each do |entry|
+        entry.write_c_dir_entry(io, suppress_extra_fields: suppress_extra_fields)
+      end
       eocd_offset = io.tell
       cdir_size = eocd_offset - cdir_offset
       if Zip.write_zip64_support &&
@@ -141,28 +143,27 @@ module Zip
       zip64_eocd_offset
     end
 
-    def unpack_e_o_c_d(buffer) # :nodoc:
+    # Unpack the EOCD and return a boolean indicating whether this header is
+    # complete without needing Zip64 extensions.
+    def unpack_e_o_c_d(buffer) # :nodoc: # rubocop:disable Naming/PredicateMethod
       _, # END_OF_CD_SIG. We know we have this at this point.
-      num_disk,
-      num_disk_cdir,
-      num_cdir_disk,
-      num_entries,
-      size_in_bytes,
-      cdir_offset,
+      @number_of_this_disk,
+      @number_of_disk_with_start_of_cdir,
+      @total_number_of_entries_in_cdir_on_this_disk,
+      @size,
+      @size_in_bytes,
+      @cdir_offset,
       comment_length = buffer.unpack('VvvvvVVv')
 
-      @number_of_this_disk = num_disk unless num_disk == 0xFFFF
-      @number_of_disk_with_start_of_cdir = num_disk_cdir unless num_disk_cdir == 0xFFFF
-      @total_number_of_entries_in_cdir_on_this_disk = num_cdir_disk unless num_cdir_disk == 0xFFFF
-      @size = num_entries unless num_entries == 0xFFFF
-      @size_in_bytes = size_in_bytes unless size_in_bytes == 0xFFFFFFFF
-      @cdir_offset = cdir_offset unless cdir_offset == 0xFFFFFFFF
-
       @comment = if comment_length.positive?
                    buffer.slice(STATIC_EOCD_SIZE, comment_length)
                  else
                    ''
                  end
+
+      !([@number_of_this_disk, @number_of_disk_with_start_of_cdir,
+         @total_number_of_entries_in_cdir_on_this_disk, @size].any?(0xFFFF) ||
+         @size_in_bytes == 0xFFFFFFFF || @cdir_offset == 0xFFFFFFFF)
     end
 
     def read_central_directory_entries(io) # :nodoc:
@@ -182,7 +183,7 @@ module Zip
         next unless entry
 
         offset = if entry.zip64?
-                   entry.extra['Zip64'].relative_header_offset
+                   entry.extra[:zip64].relative_header_offset
                  else
                    entry.local_header_offset
                  end
@@ -215,30 +216,37 @@ module Zip
       eocd_location = data.rindex([END_OF_CD_SIG].pack('V'))
       raise Error, 'Zip end of central directory signature not found' unless eocd_location
 
-      zip64_eocd_locator = data.rindex([ZIP64_EOCD_LOCATOR_SIG].pack('V'))
-
-      if zip64_eocd_locator
-        zip64_eocd_location = data.rindex([ZIP64_END_OF_CD_SIG].pack('V'))
+      # Parse the EOCD and return if it is complete without Zip64 extensions.
+      return if unpack_e_o_c_d(data.slice(eocd_location..-1))
 
-        zip64_eocd_data =
-          if zip64_eocd_location
-            data.slice(zip64_eocd_location..zip64_eocd_locator)
-          else
-            zip64_eocd_location = unpack_64_eocd_locator(
-              data.slice(zip64_eocd_locator..eocd_location)
-            )
-            unless zip64_eocd_location
-              raise Error, 'Zip64 end of central directory signature not found'
-            end
+      # Need to read in the Zip64 EOCD locator and then the Zip64 EOCD.
+      zip64_eocd_locator = data.rindex([ZIP64_EOCD_LOCATOR_SIG].pack('V'), eocd_location)
+      unless zip64_eocd_locator
+        raise Error, 'Zip64 end of central directory locator signature expected but not found'
+      end
 
-            io.seek(zip64_eocd_location, IO::SEEK_SET)
-            io.read(base_location + zip64_eocd_locator - zip64_eocd_location)
+      # Do we already have the Zip64 EOCD in the data we've read?
+      zip64_eocd_location = data.rindex([ZIP64_END_OF_CD_SIG].pack('V'), zip64_eocd_locator)
+
+      zip64_eocd_data =
+        if zip64_eocd_location
+          # Yes.
+          data.slice(zip64_eocd_location..zip64_eocd_locator)
+        else
+          # No. Read its location from the locator and then read it in.
+          zip64_eocd_location = unpack_64_eocd_locator(
+            data.slice(zip64_eocd_locator..eocd_location)
+          )
+          unless zip64_eocd_location
+            raise Error, 'Zip64 end of central directory signature not found'
           end
 
-        unpack_64_e_o_c_d(zip64_eocd_data)
-      end
+          io.seek(zip64_eocd_location, IO::SEEK_SET)
+          io.read(base_location + zip64_eocd_locator - zip64_eocd_location)
+        end
 
-      unpack_e_o_c_d(data.slice(eocd_location..-1))
+      # Finally, unpack the Zip64 EOCD.
+      unpack_64_e_o_c_d(zip64_eocd_data)
     end
 
     def eocd_data(io)

data/lib/zip/crypto/aes_encryption.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module Zip
+  module AESEncryption # :nodoc:
+    VERIFIER_LENGTH = 2
+    BLOCK_SIZE = 16
+    AUTHENTICATION_CODE_LENGTH = 10
+
+    VERSION_AE_1 = 0x01
+    VERSION_AE_2 = 0x02
+
+    VERSIONS = [
+      VERSION_AE_1,
+      VERSION_AE_2
+    ].freeze
+
+    STRENGTH_128_BIT = 0x01
+    STRENGTH_192_BIT = 0x02
+    STRENGTH_256_BIT = 0x03
+
+    STRENGTHS = [
+      STRENGTH_128_BIT,
+      STRENGTH_192_BIT,
+      STRENGTH_256_BIT
+    ].freeze
+
+    BITS = {
+      STRENGTH_128_BIT => 128,
+      STRENGTH_192_BIT => 192,
+      STRENGTH_256_BIT => 256
+    }.freeze
+
+    KEY_LENGTHS = {
+      STRENGTH_128_BIT => 16,
+      STRENGTH_192_BIT => 24,
+      STRENGTH_256_BIT => 32
+    }.freeze
+
+    SALT_LENGTHS = {
+      STRENGTH_128_BIT => 8,
+      STRENGTH_192_BIT => 12,
+      STRENGTH_256_BIT => 16
+    }.freeze
+
+    def initialize(password, strength)
+      @password = password
+      @strength = strength
+      @bits = BITS[@strength]
+      @key_length = KEY_LENGTHS[@strength]
+      @salt_length = SALT_LENGTHS[@strength]
+    end
+
+    def header_bytesize
+      @salt_length + VERIFIER_LENGTH
+    end
+
+    def gp_flags
+      0x0001
+    end
+  end
+
+  class AESDecrypter < Decrypter # :nodoc:
+    include AESEncryption
+
+    def decrypt(encrypted_data)
+      @hmac.update(encrypted_data)
+
+      idx = 0
+      decrypted_data = +''
+      amount_to_read = encrypted_data.size
+
+      while amount_to_read.positive?
+        @cipher.iv = [@counter + 1].pack('Vx12')
+        begin_index = BLOCK_SIZE * idx
+        end_index = begin_index + [BLOCK_SIZE, amount_to_read].min
+        decrypted_data << @cipher.update(encrypted_data[begin_index...end_index])
+        amount_to_read -= BLOCK_SIZE
+        @counter += 1
+        idx += 1
+      end
+
+      # JRuby requires finalization of the cipher. This is a bug, as noted in
+      # jruby/jruby-openssl#182 and jruby/jruby-openssl#183.
+      decrypted_data << @cipher.final if defined?(JRUBY_VERSION)
+      decrypted_data
+    end
+
+    def reset!(header)
+      raise Error, "Unsupported encryption AES-#{@bits}" unless STRENGTHS.include? @strength
+
+      salt = header[0...@salt_length]
+      pwd_verify = header[-VERIFIER_LENGTH..]
+      key_material = OpenSSL::KDF.pbkdf2_hmac(
+        @password,
+        salt:       salt,
+        iterations: 1000,
+        length:     (2 * @key_length) + VERIFIER_LENGTH,
+        hash:       'sha1'
+      )
+      enc_key = key_material[0...@key_length]
+      enc_hmac_key = key_material[@key_length...(2 * @key_length)]
+      enc_pwd_verify = key_material[-VERIFIER_LENGTH..]
+
+      raise Error, 'Bad password' if enc_pwd_verify != pwd_verify
+
+      @counter = 0
+      @cipher = OpenSSL::Cipher::AES.new(@bits, :CTR)
+      @cipher.decrypt
+      @cipher.key = enc_key
+      @hmac = OpenSSL::HMAC.new(enc_hmac_key, OpenSSL::Digest.new('SHA1'))
+    end
+
+    def check_integrity!(io)
+      auth_code = io.read(AUTHENTICATION_CODE_LENGTH)
+      raise Error, 'Integrity fault' if @hmac.digest[0...AUTHENTICATION_CODE_LENGTH] != auth_code
+    end
+  end
+end

data/lib/zip/crypto/decrypted_io.rb

@@ -4,39 +4,43 @@ module Zip
   class DecryptedIo # :nodoc:all
     CHUNK_SIZE = 32_768
 
-    def initialize(io, decrypter)
+    def initialize(io, decrypter, compressed_size)
       @io = io
       @decrypter = decrypter
+      @bytes_remaining = compressed_size
+      @buffer = +''
     end
 
     def read(length = nil, outbuf = +'')
-      return (length.nil? || length.zero? ? '' : nil) if eof
+      return (length.nil? || length.zero? ? '' : nil) if eof?
 
-      while length.nil? || (buffer.bytesize < length)
+      while length.nil? || (@buffer.bytesize < length)
         break if input_finished?
 
-        buffer << produce_input
+        @buffer << produce_input
       end
 
-      outbuf.replace(buffer.slice!(0...(length || buffer.bytesize)))
+      @decrypter.check_integrity!(@io) if input_finished?
+
+      outbuf.replace(@buffer.slice!(0...(length || @buffer.bytesize)))
     end
 
     private
 
-    def eof
-      buffer.empty? && input_finished?
-    end
-
-    def buffer
-      @buffer ||= +''
+    def eof?
+      @buffer.empty? && input_finished?
     end
 
     def input_finished?
-      @io.eof
+      !@bytes_remaining.positive?
     end
 
     def produce_input
-      @decrypter.decrypt(@io.read(CHUNK_SIZE))
+      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/null_encryption.rb

@@ -28,16 +28,6 @@ module Zip
 
     def reset!; end
   end
-
-  class NullDecrypter < Decrypter # :nodoc:
-    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

@@ -86,6 +86,8 @@ module Zip
       end
     end
 
+    def check_integrity!(_io); end
+
     private
 
     def decode(num)

data/lib/zip/dos_time.rb

@@ -21,7 +21,7 @@ module Zip
     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? ? true : @absolute_time
+      @absolute_time.nil? || @absolute_time
     end
 
     def to_binary_dos_time
@@ -36,7 +36,8 @@ module Zip
         ((year - 1980) << 9)
     end
 
-    def dos_equals(other)
+    # 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