omnizip 0.3.1

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

@@ -0,0 +1,117 @@
+# 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"
+require_relative "constants"
+require_relative "../../error"
+
+module Omnizip
+  module Formats
+    module XzFormat
+      # 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,55 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require "zlib"
+require_relative "../../error"
+
+module Omnizip
+  module Formats
+    module XzFormat
+      # 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,108 @@
+# 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"
+require_relative "constants"
+require_relative "../../error"
+require_relative "../../checksums/verifier"
+
+module Omnizip
+  module Formats
+    module XzFormat
+      # 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 XzFormat
+      # 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