omnizip 0.4.7-arm-linux

data/lib/omnizip/formats/xz_impl/stream_footer_parser.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require "zlib"
+
+module Omnizip
+  module Formats
+    module XzImpl
+      # XZ Stream Footer parser
+      #
+      # Stream Footer format (12 bytes):
+      # - CRC32: of backward_size + flags (4 bytes, little-endian)
+      # - Backward Size: size of Index in 4-byte units (4 bytes, little-endian)
+      # - Stream Flags: same as in Stream Header (2 bytes)
+      # - Magic: 0x59 0x5A (2 bytes)
+      #
+      # Reference: /tmp/xz-source/src/liblzma/common/stream_footer_decoder.c
+      class StreamFooterParser
+        # Stream footer magic bytes (reverse of header magic)
+        FOOTER_MAGIC = [0x59, 0x5A].freeze
+
+        # Stream footer size in bytes
+        FOOTER_SIZE = 12
+
+        # Parse stream footer from input stream
+        #
+        # @param input [IO] Input stream positioned at footer start
+        # @return [Hash] Parsed footer data with keys:
+        #   - backward_size: Integer (size of Index in 4-byte units)
+        #   - check_type: Integer (0=None, 1=CRC32, 4=CRC64, 10=SHA256)
+        # @raise [RuntimeError] If footer is invalid or CRC mismatch
+        def self.parse(input)
+          # Read 12 bytes
+          footer = input.read(FOOTER_SIZE)
+          if footer.nil? || footer.bytesize < FOOTER_SIZE
+            raise FormatError,
+                  "Unexpected end of file: incomplete stream footer"
+          end
+
+          # Verify magic bytes (last 2 bytes)
+          magic = footer[-2..].bytes
+          unless magic == FOOTER_MAGIC
+            raise FormatError, "Invalid XZ footer magic: got #{magic.map do |b|
+              b.to_s(16).upcase
+            end.join(' ')}"
+          end
+
+          # Parse CRC32 (first 4 bytes)
+          stored_crc = footer[0..3].unpack1("V")
+
+          # Parse backward size (next 4 bytes, little-endian)
+          backward_size = footer[4..7].unpack1("V")
+
+          # Parse stream flags (next 2 bytes)
+          flags = footer[8..9]
+
+          # Byte 8: reserved (must be 0)
+          if flags.getbyte(0) != 0
+            raise FormatError,
+                  "Invalid stream footer: reserved byte is non-zero"
+          end
+
+          # Byte 9: check type (low 4 bits) + reserved (high 4 bits)
+          check_flags = flags.getbyte(1)
+          check_type = check_flags & 0x0F
+          reserved = (check_flags >> 4) & 0x0F
+
+          if reserved != 0
+            raise FormatError,
+                  "Invalid stream footer: reserved bits are non-zero"
+          end
+
+          # Validate check type
+          unless [0, 1, 4, 10].include?(check_type)
+            raise FormatError, "Invalid check type in footer: #{check_type}"
+          end
+
+          # Verify CRC32
+          # CRC is calculated over backward_size + flags (bytes 4-9)
+          crc_data = footer[4..9]
+          actual_crc = Zlib.crc32(crc_data)
+
+          if actual_crc != stored_crc
+            raise FormatError,
+                  "Stream footer CRC mismatch: expected #{stored_crc}, got #{actual_crc}"
+          end
+
+          {
+            backward_size: backward_size,
+            check_type: check_type,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/xz_impl/stream_header.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Omnizip
+  module Formats
+    module XzImpl
+      # XZ Stream Header encoder
+      # Based on XZ Utils stream_flags_encoder.c
+      class StreamHeader
+        include Omnizip::Formats::XzConst
+
+        attr_reader :check_type
+
+        def initialize(check_type: CHECK_CRC64)
+          @check_type = check_type
+        end
+
+        # Encode stream header (12 bytes total)
+        # Format:
+        #   - Magic (6 bytes): FD 37 7A 58 5A 00
+        #   - Stream Flags (2 bytes): version + check type
+        #   - CRC32 (4 bytes): CRC32 of Stream Flags
+        def encode
+          output = String.new(encoding: Encoding::BINARY)
+
+          # Write magic bytes
+          output << MAGIC.pack("C*")
+
+          # Write stream flags (2 bytes)
+          flags = encode_stream_flags
+          output << flags
+
+          # Write CRC32 of stream flags
+          crc = Zlib.crc32(flags)
+          output << [crc].pack("V") # Little-endian uint32
+
+          output
+        end
+
+        def encode_stream_flags
+          # Stream Flags format:
+          #   Byte 0: Reserved (must be 0x00)
+          #   Byte 1: Check type
+          flags = String.new(encoding: Encoding::BINARY)
+          flags << "\x00" # Reserved byte
+          flags << [@check_type].pack("C")
+          flags
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/xz_impl/stream_header_parser.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require "zlib"
+
+module Omnizip
+  module Formats
+    module XzImpl
+      # XZ Stream Header parser
+      #
+      # Stream Header format (12 bytes):
+      # - Magic: 0xFD 0x37 0x7A 0x58 0x5A 0x00 (6 bytes)
+      # - Stream Flags: check_type and reserved (2 bytes)
+      # - CRC32: of magic + flags (4 bytes, little-endian)
+      #
+      # Reference: /tmp/xz-source/src/liblzma/common/stream_header_decoder.c
+      class StreamHeaderParser
+        # Stream header magic bytes
+        HEADER_MAGIC = [0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00].freeze
+
+        # Stream header size in bytes
+        HEADER_SIZE = 12
+
+        # Parse stream header from input stream
+        #
+        # @param input [IO] Input stream positioned at stream start
+        # @return [Hash] Parsed header data with keys:
+        #   - check_type: Integer (0=None, 1=CRC32, 4=CRC64, 10=SHA256)
+        # @raise [RuntimeError] If header is invalid or CRC mismatch
+        def self.parse(input)
+          # Read 12 bytes
+          header = input.read(HEADER_SIZE)
+          if header.nil? || header.bytesize < HEADER_SIZE
+            raise FormatError,
+                  "Unexpected end of file: incomplete stream header"
+          end
+
+          # Verify magic bytes (first 6 bytes)
+          magic = header[0..5].bytes
+          unless magic == HEADER_MAGIC
+            raise FormatError, "Invalid XZ magic bytes: got #{magic.map do |b|
+              b.to_s(16).upcase
+            end.join(' ')}"
+          end
+
+          # Extract stream flags (bytes 6-7)
+          flags = header[6..7]
+
+          # Byte 6: reserved (must be 0)
+          if flags.getbyte(0) != 0
+            raise FormatError, "Invalid stream flags: reserved byte is non-zero"
+          end
+
+          # Byte 7: check type (low 4 bits) + reserved (high 4 bits)
+          check_flags = flags.getbyte(1)
+          check_type = check_flags & 0x0F
+          reserved = (check_flags >> 4) & 0x0F
+
+          if reserved != 0
+            raise FormatError,
+                  "Invalid stream flags: reserved bits are non-zero"
+          end
+
+          # Validate check type (only 0, 1, 4, 10 are valid)
+          unless [0, 1, 4, 10].include?(check_type)
+            raise FormatError,
+                  "Unsupported check type: #{check_type} (not supported)"
+          end
+
+          # Verify CRC32 (bytes 8-11)
+          # IMPORTANT: CRC is calculated ONLY over Stream Flags (2 bytes), NOT magic!
+          # Reference: /tmp/xz-source/src/liblzma/common/stream_flags_decoder.c
+          crc_data = flags # Only flags, not magic
+          stored_crc = header[8..11].unpack1("V")
+          actual_crc = Zlib.crc32(crc_data)
+
+          if actual_crc != stored_crc
+            raise FormatError,
+                  "Stream header CRC mismatch: expected #{stored_crc}, got #{actual_crc}"
+          end
+
+          { check_type: check_type }
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/xz_impl/vli.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+module Omnizip
+  module Formats
+    module XzImpl
+      # Variable-Length Integer (VLI) codec for XZ format
+      #
+      # XZ format uses VLIs extensively for encoding sizes and counts.
+      # Each byte has the format: 0xxxxxxx (continue) or 1xxxxxxx (last)
+      # Maximum value is 2^63 - 1 (63 bits of data)
+      #
+      # Reference: /tmp/xz-source/src/liblzma/common/vli_decoder.c
+      module VLI
+        # Maximum VLI value (63 bits, as per XZ spec)
+        MAX_VALUE = (1 << 63) - 1
+
+        # Decode a VLI from input stream
+        #
+        # @param input [IO] Input stream
+        # @return [Integer] Decoded value
+        # @raise [Omnizip::IOError, Omnizip::FormatError] If VLI is invalid or exceeds maximum
+        def self.decode(input)
+          result = 0
+          shift = 0
+          byte_count = 0
+
+          loop do
+            byte = input.getbyte
+            if byte.nil?
+              raise Omnizip::IOError,
+                    "Unexpected end of stream in VLI"
+            end
+            byte_count += 1
+
+            if shift >= 63
+              raise Omnizip::FormatError,
+                    "VLI overflow (shift=#{shift}, max=63)"
+            end
+
+            # Add lower 7 bits to result
+            result |= (byte & 0x7F) << shift
+
+            # Check if continuation bit is set
+            break if byte.nobits?(0x80)
+
+            shift += 7
+          end
+
+          if result > MAX_VALUE
+            raise Omnizip::FormatError,
+                  "VLI exceeds maximum (#{result} > #{MAX_VALUE})"
+          end
+
+          # XZ spec: VLIs must use minimum encoding
+          # Reference: /Users/mulgogi/src/external/xz/src/liblzma/common/vli_decoder.c:77-83
+          # If more than 1 byte was used, the value must be large enough to require it
+          # For example, value 13 can be encoded as 0x0D (1 byte) but NOT as 0x8D 0x00 (2 bytes)
+          if byte_count > 1 && result < (1 << (7 * (byte_count - 1)))
+            raise FormatError,
+                  "VLI not minimally encoded: value #{result} uses #{byte_count} bytes, " \
+                  "but minimum is #{size(result)} bytes"
+          end
+
+          result
+        end
+
+        # Encode a value as VLI (for testing and validation)
+        #
+        # @param value [Integer] Value to encode
+        # @return [String] Encoded bytes
+        # @raise [Omnizip::FormatError] If value exceeds maximum
+        def self.encode(value)
+          if value > MAX_VALUE
+            raise Omnizip::FormatError,
+                  "VLI value #{value} exceeds maximum #{MAX_VALUE}"
+          end
+
+          bytes = []
+          loop do
+            byte = value & 0x7F
+            value >>= 7
+
+            # Set continuation bit if more bytes remain
+            byte |= 0x80 if value.positive?
+
+            bytes << byte
+            break if value.zero?
+          end
+          bytes.pack("C*")
+        end
+
+        # Calculate encoded size of a VLI value
+        #
+        # @param value [Integer] Value to measure
+        # @return [Integer] Number of bytes needed to encode
+        def self.size(value)
+          size = 1
+          value >>= 7
+          while value.positive?
+            size += 1
+            value >>= 7
+          end
+          size
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/xz_impl.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    # XZ format implementation namespace
+    #
+    # This module contains XZ format implementation components.
+    # Classes are autoloaded for lazy loading.
+    module XzImpl
+      # Variable-Length Integer codec
+      autoload :VLI, "omnizip/formats/xz_impl/vli"
+
+      # XZ block header encoder
+      autoload :BlockHeader, "omnizip/formats/xz_impl/block_header"
+
+      # XZ block header parser
+      autoload :BlockHeaderParser, "omnizip/formats/xz_impl/block_header_parser"
+
+      # XZ block encoder
+      autoload :BlockEncoder, "omnizip/formats/xz_impl/block_encoder"
+
+      # XZ block decoder
+      autoload :BlockDecoder, "omnizip/formats/xz_impl/block_decoder"
+
+      # XZ index encoder
+      autoload :IndexEncoder, "omnizip/formats/xz_impl/index_encoder"
+
+      # XZ index decoder
+      autoload :IndexDecoder, "omnizip/formats/xz_impl/index_decoder"
+
+      # XZ stream header encoder
+      autoload :StreamHeader, "omnizip/formats/xz_impl/stream_header"
+
+      # XZ stream header parser
+      autoload :StreamHeaderParser,
+               "omnizip/formats/xz_impl/stream_header_parser"
+
+      # XZ stream footer encoder
+      autoload :StreamFooter, "omnizip/formats/xz_impl/stream_footer"
+
+      # XZ stream footer parser
+      autoload :StreamFooterParser,
+               "omnizip/formats/xz_impl/stream_footer_parser"
+
+      # XZ stream encoder
+      autoload :StreamEncoder, "omnizip/formats/xz_impl/stream_encoder"
+
+      # XZ stream decoder
+      autoload :StreamDecoder, "omnizip/formats/xz_impl/stream_decoder"
+    end
+  end
+end

data/lib/omnizip/formats/zip/central_directory_header.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Zip
+      # ZIP Central Directory File Header
+      class CentralDirectoryHeader
+        include Omnizip::Formats::Zip::Constants
+
+        attr_accessor :signature, :version_made_by, :version_needed, :flags,
+                      :compression_method, :last_mod_time, :last_mod_date,
+                      :crc32, :compressed_size, :uncompressed_size,
+                      :filename_length, :extra_field_length, :comment_length,
+                      :disk_number_start, :internal_attributes, :external_attributes,
+                      :local_header_offset, :filename, :extra_field, :comment,
+                      :cached_original_data
+
+        def initialize(
+          signature: CENTRAL_DIRECTORY_SIGNATURE,
+          version_made_by: VERSION_MADE_BY_UNIX,
+          version_needed: VERSION_DEFAULT,
+          flags: 0,
+          compression_method: COMPRESSION_STORE,
+          last_mod_time: 0,
+          last_mod_date: 0,
+          crc32: 0,
+          compressed_size: 0,
+          uncompressed_size: 0,
+          filename_length: 0,
+          extra_field_length: 0,
+          comment_length: 0,
+          disk_number_start: 0,
+          internal_attributes: 0,
+          external_attributes: 0,
+          local_header_offset: 0,
+          filename: "",
+          extra_field: "",
+          comment: ""
+        )
+          @signature = signature
+          @version_made_by = version_made_by
+          @version_needed = version_needed
+          @flags = flags
+          @compression_method = compression_method
+          @last_mod_time = last_mod_time
+          @last_mod_date = last_mod_date
+          @crc32 = crc32
+          @compressed_size = compressed_size
+          @uncompressed_size = uncompressed_size
+          @filename_length = filename_length
+          @extra_field_length = extra_field_length
+          @comment_length = comment_length
+          @disk_number_start = disk_number_start
+          @internal_attributes = internal_attributes
+          @external_attributes = external_attributes
+          @local_header_offset = local_header_offset
+          @filename = filename
+          @extra_field = extra_field
+          @comment = comment
+        end
+
+        # Check if this is a directory entry
+        # DOS date/time (as stored in the central directory) to Time
+        def time
+          year = ((last_mod_date >> 9) & 0x7F) + 1980
+          month = (last_mod_date >> 5) & 0x0F
+          day = last_mod_date & 0x1F
+          hour = (last_mod_time >> 11) & 0x1F
+          minute = (last_mod_time >> 5) & 0x3F
+          second = (last_mod_time & 0x1F) * 2
+          Time.new(year, month, day, hour, minute, second)
+        rescue ArgumentError
+          nil
+        end
+
+        # Omnizip::Entry contract
+        def entry_name
+          filename
+        end
+
+        def entry_directory?
+          directory?
+        end
+
+        def entry_size
+          uncompressed_size
+        end
+
+        def entry_mtime
+          time
+        end
+
+        def directory?
+          filename.end_with?("/") ||
+            external_attributes.anybits?(ATTR_DIRECTORY)
+        end
+
+        # Check if ZIP64 format is needed
+        def zip64?
+          compressed_size == ZIP64_LIMIT ||
+            uncompressed_size == ZIP64_LIMIT ||
+            local_header_offset == ZIP64_LIMIT ||
+            disk_number_start == 0xFFFF
+        end
+
+        # Check if entry is encrypted
+        def encrypted?
+          flags.anybits?(FLAG_ENCRYPTED)
+        end
+
+        # Check if UTF-8 encoding is used
+        def utf8?
+          flags.anybits?(FLAG_UTF8)
+        end
+
+        # Get Unix permissions from external attributes
+        def unix_permissions
+          (external_attributes >> 16) & 0xFFFF
+        end
+
+        # Set Unix permissions in external attributes
+        def unix_permissions=(perms)
+          @external_attributes = (perms << 16) | (external_attributes & 0xFFFF)
+        end
+
+        # Check if this is a symbolic link
+        def symlink?
+          (unix_permissions & 0o170000) == 0o120000
+        end
+
+        # Get link target from Unix extra field
+        def link_target
+          return nil unless symlink?
+
+          unix_field = UnixExtraField.find_in_extra_field(extra_field)
+          unix_field&.link_target
+        end
+
+        # Serialize to binary format
+        def to_binary
+          @filename_length = filename.bytesize
+          @extra_field_length = extra_field.bytesize
+          @comment_length = comment.bytesize
+
+          [
+            signature,
+            version_made_by,
+            version_needed,
+            flags,
+            compression_method,
+            last_mod_time,
+            last_mod_date,
+            crc32,
+            compressed_size,
+            uncompressed_size,
+            filename_length,
+            extra_field_length,
+            comment_length,
+            disk_number_start,
+            internal_attributes,
+            external_attributes,
+            local_header_offset,
+          ].pack("VvvvvvvVVVvvvvvVV") +
+            filename.b +
+            extra_field.b +
+            comment.b
+        end
+
+        # Parse from binary data
+        def self.from_binary(data)
+          signature, version_made_by, version_needed, flags,
+          compression_method, last_mod_time, last_mod_date,
+          crc32, compressed_size, uncompressed_size,
+          filename_length, extra_field_length, comment_length,
+          disk_number_start, internal_attributes,
+          external_attributes, local_header_offset = data.unpack("VvvvvvvVVVvvvvvVV")
+
+          unless signature == CENTRAL_DIRECTORY_SIGNATURE
+            raise Omnizip::FormatError,
+                  "Invalid central directory signature"
+          end
+
+          offset = 46
+          filename = data[offset, filename_length].force_encoding("UTF-8")
+          offset += filename_length
+
+          extra_field = data[offset, extra_field_length]
+          offset += extra_field_length
+
+          comment = data[offset, comment_length].force_encoding("UTF-8")
+
+          new(
+            signature: signature,
+            version_made_by: version_made_by,
+            version_needed: version_needed,
+            flags: flags,
+            compression_method: compression_method,
+            last_mod_time: last_mod_time,
+            last_mod_date: last_mod_date,
+            crc32: crc32,
+            compressed_size: compressed_size,
+            uncompressed_size: uncompressed_size,
+            filename_length: filename_length,
+            extra_field_length: extra_field_length,
+            comment_length: comment_length,
+            disk_number_start: disk_number_start,
+            internal_attributes: internal_attributes,
+            external_attributes: external_attributes,
+            local_header_offset: local_header_offset,
+            filename: filename,
+            extra_field: extra_field,
+            comment: comment,
+          )
+        end
+
+        # Size of the header in bytes
+        def header_size
+          46 + filename_length + extra_field_length + comment_length
+        end
+      end
+    end
+  end
+end