omnizip 0.3.1

data/lib/omnizip/formats/seven_zip/coder_chain.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "../../algorithm_registry"
+require_relative "../../filter_registry"
+require_relative "../../filter_pipeline"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Builds coder chains from .7z folder specifications
+      # Maps method IDs to algorithms and filters, reconstructing the
+      # decompression pipeline
+      class CoderChain
+        include Constants
+
+        # Build coder chain from folder specification
+        #
+        # @param folder [Models::Folder] Folder specification
+        # @return [Hash] Coder chain configuration
+        # @raise [RuntimeError] if unsupported method encountered
+        def self.build_from_folder(folder)
+          return nil if folder.coders.empty?
+
+          # For now, support single coder or coder+filter combinations
+          main_coder = folder.coders.last
+          algorithm = algorithm_for_method(main_coder.method_id)
+
+          # Check for filters
+          filters = []
+          if folder.coders.size > 1
+            folder.coders[0..-2].each do |coder|
+              filter = filter_for_method(coder.method_id)
+              filters << filter if filter
+            end
+          end
+
+          {
+            algorithm: algorithm,
+            filters: filters,
+            properties: main_coder.properties,
+            unpack_size: folder.unpack_sizes.last,
+          }
+        end
+
+        # Map method ID to algorithm
+        #
+        # @param method_id [Integer] Method ID from .7z file
+        # @return [Symbol] Algorithm identifier
+        # @raise [RuntimeError] if method not supported
+        def self.algorithm_for_method(method_id)
+          case method_id
+          when MethodId::COPY
+            nil # No decompression needed
+          when MethodId::LZMA
+            :lzma
+          when MethodId::LZMA2
+            :lzma2
+          when MethodId::PPMD
+            :ppmd7
+          when MethodId::BZIP2
+            :bzip2
+          when MethodId::DEFLATE
+            :deflate
+          when MethodId::DEFLATE64
+            :deflate64
+          else
+            raise "Unsupported compression method: " \
+                  "0x#{method_id.to_s(16)}"
+          end
+        end
+
+        # Map method ID to filter
+        #
+        # @param method_id [Integer] Method ID from .7z file
+        # @return [Symbol, nil] Filter identifier or nil
+        def self.filter_for_method(method_id)
+          case method_id
+          when FilterId::BCJ_X86
+            :bcj_x86
+          when FilterId::BCJ_PPC
+            :bcj_ppc
+          when FilterId::BCJ_IA64
+            :bcj_ia64
+          when FilterId::BCJ_ARM
+            :bcj_arm
+          when FilterId::BCJ_ARMT
+            :bcj_armt
+          when FilterId::BCJ_SPARC
+            :bcj_sparc
+          when FilterId::ARM64
+            :bcj_arm64
+          when FilterId::DELTA
+            :delta
+          end
+        end
+
+        # Create decompressor for coder chain
+        #
+        # @param chain_config [Hash] Chain configuration
+        # @param input_io [IO] Input stream
+        # @return [Object] Decompressor instance
+        def self.create_decompressor(chain_config, input_io)
+          return nil unless chain_config
+          return input_io unless chain_config[:algorithm]
+
+          # Get algorithm
+          algo_class = AlgorithmRegistry.get(chain_config[:algorithm])
+          unless algo_class
+            raise "Algorithm not found: #{chain_config[:algorithm]}"
+          end
+
+          # Create algorithm instance
+          decompressor = algo_class.new
+          # Pass properties if algorithm supports them
+          # Some algorithms (LZMA2) need properties
+          if chain_config[:properties] && !chain_config[:properties].empty? && decompressor.respond_to?(:properties=)
+            decompressor.properties = chain_config[:properties]
+          end
+
+          # Apply filters if present
+          if chain_config[:filters] && !chain_config[:filters].empty?
+            # Build filter pipeline
+            pipeline = FilterPipeline.new
+            chain_config[:filters].each do |filter_sym|
+              filter_class = FilterRegistry.get(filter_sym)
+              raise "Filter not found: #{filter_sym}" unless filter_class
+
+              pipeline.add_filter(filter_class.new)
+            end
+
+            # Return composite: input -> algorithm -> filters
+            {
+              decompressor: decompressor,
+              pipeline: pipeline,
+              input: input_io,
+            }
+          else
+            # Just algorithm
+            {
+              decompressor: decompressor,
+              pipeline: nil,
+              input: input_io,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/constants.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Constants for .7z archive format
+      # Based on 7-Zip specification
+      module Constants
+        # Archive signature and header
+        SIGNATURE = "7z\xBC\xAF\x27\x1C".b.freeze
+        SIGNATURE_SIZE = 6
+        START_HEADER_SIZE = 32 # 0x20
+        MAJOR_VERSION = 0
+        MINOR_VERSION = 4
+
+        # Property IDs for .7z format structure
+        module PropertyId
+          K_END = 0x00
+          HEADER = 0x01
+          ARCHIVE_PROPERTIES = 0x02
+          ADDITIONAL_STREAMS_INFO = 0x03
+          MAIN_STREAMS_INFO = 0x04
+          FILES_INFO = 0x05
+          PACK_INFO = 0x06
+          UNPACK_INFO = 0x07
+          SUBSTREAMS_INFO = 0x08
+          SIZE = 0x09
+          CRC = 0x0A
+          FOLDER = 0x0B
+          CODERS_UNPACK_SIZE = 0x0C
+          NUM_UNPACK_STREAM = 0x0D
+          EMPTY_STREAM = 0x0E
+          EMPTY_FILE = 0x0F
+          ANTI = 0x10
+          NAME = 0x11
+          CTIME = 0x12
+          ATIME = 0x13
+          MTIME = 0x14
+          WIN_ATTRIB = 0x15
+          COMMENT = 0x16
+          ENCODED_HEADER = 0x17
+          START_POS = 0x18
+          DUMMY = 0x19
+        end
+
+        # Method IDs for compression algorithms
+        module MethodId
+          # Compression methods
+          COPY = 0x00
+          LZMA = 0x030101
+          LZMA2 = 0x21
+          PPMD = 0x030401
+          BZIP2 = 0x040202
+          DEFLATE = 0x040108
+          DEFLATE64 = 0x040109
+
+          # Crypto methods
+          AES = 0x06F10701
+
+          def self.name(id)
+            case id
+            when COPY then "Copy"
+            when LZMA then "LZMA"
+            when LZMA2 then "LZMA2"
+            when PPMD then "PPMd"
+            when BZIP2 then "BZip2"
+            when DEFLATE then "Deflate"
+            when DEFLATE64 then "Deflate64"
+            when AES then "AES256"
+            else "Unknown(0x#{id.to_s(16)})"
+            end
+          end
+        end
+
+        # Filter IDs
+        module FilterId
+          # BCJ filters for executable files
+          BCJ_X86 = 0x03030103
+          BCJ_PPC = 0x03030205
+          BCJ_IA64 = 0x03030401
+          BCJ_ARM = 0x03030501
+          BCJ_ARMT = 0x03030701
+          BCJ_SPARC = 0x03030805
+          ARM64 = 0x03030601
+
+          # BCJ2 filter
+          BCJ2 = 0x03030111
+
+          # Swap filters for byte order conversion
+          SWAP2 = 0x03030204
+          SWAP4 = 0x03030208
+
+          # Delta filter
+          DELTA = 0x03
+
+          def self.name(id)
+            case id
+            when BCJ_X86 then "BCJ-x86"
+            when BCJ_PPC then "BCJ-PPC"
+            when BCJ_IA64 then "BCJ-IA64"
+            when BCJ_ARM then "BCJ-ARM"
+            when BCJ_ARMT then "BCJ-ARMT"
+            when BCJ_SPARC then "BCJ-SPARC"
+            when DELTA then "Delta"
+            when ARM64 then "BCJ-ARM64"
+            when BCJ2 then "BCJ2"
+            when SWAP2 then "Swap2"
+            when SWAP4 then "Swap4"
+            else "Unknown(0x#{id.to_s(16)})"
+            end
+          end
+
+          def self.bcj_filter?(id)
+            [BCJ_X86, BCJ_PPC, BCJ_IA64, BCJ_ARM, BCJ_ARMT, BCJ_SPARC,
+             ARM64].include?(id)
+          end
+        end
+
+        # Maximum limits
+        MAX_NUM_CODERS = 4
+        MAX_NUM_BONDS = 3
+        MAX_NUM_PACK_STREAMS = 4
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/encoded_header.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "../../algorithms/lzma2"
+require_relative "../../checksums/crc32"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Handles 7-Zip encoded headers
+      #
+      # 7-Zip can compress the Next Header metadata with LZMA2 to save space.
+      # This module provides functionality to encode and decode headers.
+      module EncodedHeader
+        include Constants
+
+        module_function
+
+        # Encode next header with LZMA2 compression
+        #
+        # @param header_data [String] Uncompressed header data
+        # @return [String] Encoded header property with compressed data
+        def encode(header_data)
+          # Compress header with LZMA2
+          compressed = compress_header(header_data)
+
+          # Build encoded header property
+          encoded = String.new(encoding: "BINARY")
+          encoded << [PropertyId::ENCODED_HEADER].pack("C")
+
+          # Write pack info for compressed header
+          encoded << [PropertyId::PACK_INFO].pack("C")
+          encoded << encode_uint64(0)  # Pack position
+          encoded << encode_uint64(1)  # Number of pack streams
+
+          # Write size
+          encoded << [PropertyId::SIZE].pack("C")
+          encoded << encode_uint64(compressed.bytesize)
+
+          encoded << [PropertyId::K_END].pack("C")
+
+          # Write coder info (LZMA2)
+          encoded << [PropertyId::UNPACK_INFO].pack("C")
+          encoded << [PropertyId::FOLDER].pack("C")
+          encoded << encode_uint64(1)  # Number of folders
+          encoded << [0].pack("C")     # External flag (0 = inline)
+
+          # Number of coders
+          encoded << encode_uint64(1)
+
+          # Coder info for LZMA2
+          # Method ID: LZMA2 = 0x21
+          encoded << [1].pack("C") # Main byte (1 byte for ID, no properties)
+          encoded << [0x21].pack("C") # LZMA2 method ID
+
+          # Unpack size
+          encoded << [PropertyId::CODERS_UNPACK_SIZE].pack("C")
+          encoded << encode_uint64(header_data.bytesize)
+
+          encoded << [PropertyId::K_END].pack("C")
+
+          # Append compressed data
+          encoded << compressed
+
+          encoded
+        end
+
+        # Compress header data with LZMA2
+        #
+        # @param header_data [String] Uncompressed header
+        # @return [String] Compressed header
+        def compress_header(header_data)
+          # Use 7-Zip SDK LZMA2 encoder for 7-Zip format
+          encoder = Omnizip::Implementations::SevenZip::LZMA2::Encoder.new(
+            dict_size: 4096, # Small dictionary for headers
+            lc: 3,
+            lp: 0,
+            pb: 2,
+            standalone: false, # No property byte
+          )
+
+          encoder.encode(header_data)
+        end
+
+        # Encode unsigned 64-bit integer in 7-Zip variable-length format
+        #
+        # @param value [Integer] Value to encode
+        # @return [String] Encoded bytes
+        def encode_uint64(value)
+          return [value].pack("C") if value < 0x80
+
+          result = String.new(encoding: "BINARY")
+          shift = 0
+
+          loop do
+            byte = value & 0x7F
+            value >>= 7
+
+            if value.zero?
+              result << [byte].pack("C")
+              break
+            else
+              result << [byte | 0x80].pack("C")
+            end
+
+            shift += 7
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/encrypted_header.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Encrypted header model for .7z archives
+      # Stores metadata for header encryption
+      class EncryptedHeader
+        include Constants
+
+        attr_accessor :encrypted_data, :salt, :iv, :original_size, :crc
+
+        # Initialize encrypted header
+        #
+        # @param encrypted_data [String] Encrypted header bytes
+        # @param salt [String] PBKDF2 salt
+        # @param iv [String] AES initialization vector
+        # @param original_size [Integer] Size before encryption
+        # @param crc [Integer, nil] CRC32 of encrypted data (optional)
+        def initialize(encrypted_data: nil, salt: nil, iv: nil,
+                       original_size: 0, crc: nil)
+          @encrypted_data = encrypted_data
+          @salt = salt
+          @iv = iv
+          @original_size = original_size
+          @crc = crc
+        end
+
+        # Serialize encrypted header to binary format
+        #
+        # Format:
+        #   - 1 byte: PropertyId::ENCODED_HEADER marker
+        #   - 8 bytes: Encrypted data size (little-endian)
+        #   - 16 bytes: Salt
+        #   - 16 bytes: IV
+        #   - 8 bytes: Original size (little-endian)
+        #   - 4 bytes: CRC32 (optional, 0 if not set)
+        #   - N bytes: Encrypted data
+        #
+        # @return [String] Binary representation
+        def to_binary
+          data = String.new(encoding: "BINARY")
+
+          # Marker for encoded header
+          data << [PropertyId::ENCODED_HEADER].pack("C")
+
+          # Encrypted data size
+          data << [@encrypted_data.bytesize].pack("Q<")
+
+          # Encryption parameters
+          data << @salt
+          data << @iv
+
+          # Original size
+          data << [@original_size].pack("Q<")
+
+          # CRC (0 if not set)
+          data << [crc || 0].pack("V")
+
+          # Encrypted data
+          data << @encrypted_data
+
+          data
+        end
+
+        # Parse encrypted header from binary data
+        #
+        # @param data [String] Binary data
+        # @return [EncryptedHeader] Parsed header
+        # @raise [RuntimeError] if data is invalid
+        def self.from_binary(data)
+          raise "Invalid encrypted header: too short" if data.bytesize < 54
+
+          pos = 0
+
+          # Check marker
+          marker = data.getbyte(pos)
+          pos += 1
+          unless marker == PropertyId::ENCODED_HEADER
+            raise "Invalid encrypted header marker: expected #{PropertyId::ENCODED_HEADER}, got #{marker}"
+          end
+
+          # Read encrypted data size
+          encrypted_size = data[pos, 8].unpack1("Q<")
+          pos += 8
+
+          # Read salt
+          salt = data[pos, 16]
+          pos += 16
+
+          # Read IV
+          iv = data[pos, 16]
+          pos += 16
+
+          # Read original size
+          original_size = data[pos, 8].unpack1("Q<")
+          pos += 8
+
+          # Read CRC
+          crc = data[pos, 4].unpack1("V")
+          pos += 4
+
+          # Read encrypted data
+          encrypted_data = data[pos, encrypted_size]
+
+          new(
+            encrypted_data: encrypted_data,
+            salt: salt,
+            iv: iv,
+            original_size: original_size,
+            crc: crc.zero? ? nil : crc,
+          )
+        end
+
+        # Check if header is valid
+        #
+        # @return [Boolean] true if has all required fields
+        def valid?
+          !@encrypted_data.nil? &&
+            !@salt.nil? &&
+            !@iv.nil? &&
+            @original_size.positive? &&
+            @encrypted_data.bytesize.positive?
+        end
+
+        # Verify CRC if set
+        #
+        # @return [Boolean] true if CRC matches or not set
+        def verify_crc
+          return true if @crc.nil?
+
+          require_relative "../../checksums/crc32"
+          calc_crc = Omnizip::Checksums::Crc32.new
+          calc_crc.update(@encrypted_data)
+          calc_crc.value == @crc
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/file_collector.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "models/file_entry"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Collects files and directories for archiving
+      # Handles file metadata, timestamps, and attributes
+      class FileCollector
+        attr_reader :entries
+
+        # Initialize collector
+        def initialize
+          @entries = []
+          @base_path = nil
+        end
+
+        # Add path (file or directory) to collection
+        #
+        # @param path [String] Path to file or directory
+        # @param archive_path [String, nil] Path in archive (nil = auto)
+        # @param recursive [Boolean] Recursively add directories
+        def add_path(path, archive_path: nil, recursive: true)
+          path = File.expand_path(path)
+          raise "Path not found: #{path}" unless File.exist?(path)
+
+          @base_path ||= File.dirname(path)
+
+          if File.directory?(path)
+            add_directory(path, archive_path, recursive)
+          else
+            add_file(path, archive_path)
+          end
+        end
+
+        # Add files matching glob pattern
+        #
+        # @param pattern [String] Glob pattern
+        # @param base_path [String, nil] Base path for relative names
+        def add_glob(pattern, base_path: nil)
+          @base_path ||= base_path || Dir.pwd
+
+          Dir.glob(pattern).each do |path|
+            add_path(path)
+          end
+        end
+
+        # Get collected file entries
+        #
+        # @return [Array<Models::FileEntry>] File entries
+        def collect_files
+          @entries.sort_by(&:name)
+        end
+
+        private
+
+        # Add single file
+        #
+        # @param file_path [String] Full path to file
+        # @param archive_path [String, nil] Path in archive
+        def add_file(file_path, archive_path)
+          archive_name = archive_path || relative_path(file_path)
+
+          entry = Models::FileEntry.new.tap do |e|
+            e.name = archive_name
+            e.size = File.size(file_path)
+            e.has_stream = e.size.positive?
+            e.is_dir = false
+            e.mtime = File.mtime(file_path)
+            e.attributes = file_attributes(file_path)
+            e.source_path = file_path
+          end
+
+          @entries << entry
+        end
+
+        # Add directory and optionally its contents
+        #
+        # @param dir_path [String] Directory path
+        # @param archive_path [String, nil] Path in archive
+        # @param recursive [Boolean] Add contents recursively
+        def add_directory(dir_path, archive_path, recursive)
+          archive_name = archive_path || relative_path(dir_path)
+          archive_name += "/" unless archive_name.end_with?("/")
+
+          # Add directory entry
+          entry = Models::FileEntry.new.tap do |e|
+            e.name = archive_name
+            e.size = 0
+            e.has_stream = false
+            e.is_dir = true
+            e.mtime = File.mtime(dir_path)
+            e.attributes = file_attributes(dir_path)
+          end
+
+          @entries << entry
+
+          return unless recursive
+
+          # Add contents
+          Dir.each_child(dir_path) do |child|
+            child_path = File.join(dir_path, child)
+            add_path(child_path, archive_path: nil, recursive: true)
+          end
+        end
+
+        # Get relative path for archive
+        #
+        # @param path [String] Full path
+        # @return [String] Relative path
+        def relative_path(path)
+          if @base_path && path.start_with?(@base_path)
+            path[@base_path.length..].sub(%r{^/}, "")
+          else
+            File.basename(path)
+          end
+        end
+
+        # Get file attributes (Unix permissions as Windows attributes)
+        #
+        # @param path [String] File path
+        # @return [Integer] Attribute flags
+        def file_attributes(path)
+          attrs = 0
+          stat = File.stat(path)
+
+          # Windows FILE_ATTRIBUTE_DIRECTORY = 0x10
+          attrs |= 0x10 if stat.directory?
+
+          # Windows FILE_ATTRIBUTE_ARCHIVE = 0x20
+          attrs |= 0x20 unless stat.directory?
+
+          # Convert Unix permissions to Windows read-only flag
+          # FILE_ATTRIBUTE_READONLY = 0x01
+          attrs |= 0x01 unless stat.writable?
+
+          attrs
+        end
+      end
+    end
+  end
+end