omnizip 0.4.7-aarch64-linux

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

@@ -0,0 +1,626 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "set"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # .7z archive reader
+      # Provides read-only access to .7z archives
+      class Reader
+        include Omnizip::Formats::SevenZip::Constants
+
+        attr_reader :file_path, :header, :entries, :stream_info, :split_reader
+
+        # Initialize reader with file path
+        #
+        # @param file_path [String] Path to .7z file
+        # @param options [Hash] Reader options
+        # @option options [String] :password Password for encrypted headers
+        # @option options [Integer] :offset Offset for embedded archives
+        def initialize(file_path, options = {})
+          @file_path = file_path
+          @entries = []
+          @stream_info = nil
+          @split_reader = nil
+          @password = options[:password]
+          @offset = options[:offset] || 0
+          @solid_cache = {}
+          @solid_cache_extracted = {}
+          @opened = false
+        end
+
+        # Open and parse .7z archive
+        #
+        # @raise [RuntimeError] if file cannot be opened or parsed
+        def open
+          # Check if this is a split archive
+          if split_archive?
+            @split_reader = SplitArchiveReader.new(@file_path)
+            @split_reader.open
+            @header = @split_reader.header
+            @entries = @split_reader.entries
+            @stream_info = @split_reader.stream_info
+          else
+            File.open(@file_path, "rb") do |io|
+              # Seek to offset for embedded archives
+              io.seek(@offset) if @offset.positive?
+              parse_archive(io)
+            end
+          end
+          self
+        end
+
+        # Check if archive is split
+        #
+        # @return [Boolean] true if split across multiple volumes
+        def split?
+          @split_reader&.split? || false
+        end
+
+        # Get total number of volumes (for split archives)
+        #
+        # @return [Integer] Number of volumes
+        def total_volumes
+          @split_reader&.total_volumes || 1
+        end
+
+        # Get volume size (for split archives)
+        #
+        # @return [Integer] Volume size in bytes
+        def volume_size
+          @split_reader&.volume_size || File.size(@file_path)
+        end
+
+        # Get list of volumes (for split archives)
+        #
+        # @return [Array<String>] Volume paths
+        def volumes
+          @split_reader&.volumes || [@file_path]
+        end
+
+        # List all files in archive, parsing on first use — a Reader
+        # is always usable; #open remains for eager loading
+        #
+        # @return [Array<Models::FileEntry>] File entries
+        def list_files
+          ensure_open
+          @entries.reject { |e| e.name.nil? || e.name.empty? }
+        end
+
+        # Extract file to output path
+        #
+        # @param entry_name [String] File name to extract
+        # @param output_path [String] Destination path
+        # @raise [RuntimeError] if entry not found or extraction fails
+        def extract_entry(entry_name, output_path)
+          ensure_open
+          # Delegate to split reader if available
+          if @split_reader
+            @split_reader.extract_entry(entry_name, output_path)
+            return
+          end
+
+          entry = @entries.find { |e| e.name == entry_name }
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
+
+          # Create directory if needed
+          FileUtils.mkdir_p(File.dirname(output_path))
+
+          # Extract file
+          if entry.directory?
+            FileUtils.mkdir_p(output_path)
+          elsif entry.has_stream?
+            File.open(@file_path, "rb") do |io|
+              # Seek to offset for embedded archives
+              io.seek(@offset) if @offset.positive?
+              data = extract_entry_data(io, entry)
+              File.binwrite(output_path, data)
+            end
+
+            # Set timestamp if available
+            if entry.mtime
+              File.utime(entry.atime || entry.mtime || Time.now,
+                         entry.mtime || Time.now,
+                         output_path)
+            end
+          else
+            # Empty file
+            FileUtils.touch(output_path)
+          end
+        end
+
+        # Extract all files to directory
+        #
+        # @param output_dir [String] Destination directory
+        # @raise [RuntimeError] on extraction error
+        def extract_all(output_dir)
+          ensure_open
+          FileUtils.mkdir_p(output_dir)
+
+          real_out = File.realpath(output_dir)
+
+          @entries.each do |entry|
+            next if entry.name.nil? || entry.name.empty?
+
+            output_path = File.join(real_out, entry.name)
+            expanded = File.expand_path(output_path)
+            unless expanded.start_with?("#{real_out}#{File::SEPARATOR}") || expanded == real_out
+              raise Omnizip::FormatError,
+                    "Path traversal detected: #{entry.name}"
+            end
+
+            extract_entry(entry.name, output_path)
+          end
+        ensure
+          @solid_cache.clear
+          @solid_cache_extracted.clear
+        end
+
+        # Check if archive is valid .7z format
+        #
+        # @return [Boolean] true if valid
+        def valid?
+          !@header.nil? && @header.valid?
+        end
+
+        # Check if headers are encrypted
+        #
+        # @return [Boolean] true if headers are encrypted
+        def encrypted?
+          !@encrypted_header.nil?
+        end
+
+        # Check if can decrypt headers (password provided)
+        #
+        # @return [Boolean] true if password available for encrypted headers
+        def can_decrypt?
+          encrypted? && !@password.nil?
+        end
+
+        # Extract raw entry payload from the archive. Public so converters
+        # and parallel extractors can reuse the stream-positioning +
+        # decompression logic.
+        #
+        # @param io [IO] Archive file handle
+        # @param entry [Models::FileEntry] Entry to extract
+        # @return [String] Extracted bytes
+        def extract_entry_data(io, entry)
+          extract_entry_data_private(io, entry)
+        end
+
+        private
+
+        # Parse the archive once, on demand
+        def ensure_open
+          open unless @opened
+        end
+
+        # Parse .7z archive structure
+        #
+        # @param io [io] Input stream
+        def parse_archive(io)
+          # Read and validate start header
+          @header = Header.read(io)
+
+          # Read next header metadata
+          # NOTE: next_header_offset is from the END of the Start Header (byte 32)
+          # NOT from the end of the file
+          # For embedded archives, add offset to get absolute position
+          next_header_pos = @offset + Constants::START_HEADER_SIZE + @header.next_header_offset
+          io.seek(next_header_pos)
+          next_header_data = io.read(@header.next_header_size)
+
+          # Check if header is encoded (compressed or encrypted)
+          # ENCODED_HEADER (0x17) can mean compressed or encrypted
+          first_byte = next_header_data.getbyte(0)
+          if first_byte == PropertyId::ENCODED_HEADER
+            # Try to parse as encrypted first (if enough data and has structure)
+            if next_header_data.bytesize >= 54
+              begin
+                # Check if it's actually an encrypted header
+                EncryptedHeader.from_binary(next_header_data)
+                # If we got here, it's encrypted - try to decrypt
+                next_header_data = decrypt_header(next_header_data)
+              rescue Omnizip::PasswordError
+                # Decryption refused or failed — a password problem,
+                # never a compressed header
+                raise
+              rescue StandardError
+                # Not an encrypted header — it's a compressed header;
+                # decompress it using the encoded stream info
+                next_header_data = decompress_encoded_header(io,
+                                                             next_header_data)
+              end
+            else
+              # Too short for encrypted header, must be compressed
+              next_header_data = decompress_encoded_header(io, next_header_data)
+            end
+          end
+
+          # Parse metadata
+          parser = Parser.new(next_header_data)
+          begin
+            @stream_info, @entries = parse_metadata(parser)
+          rescue StandardError => e
+            if @headers_decrypted
+              raise Omnizip::PasswordError, "Failed to decrypt headers: incorrect password " \
+                                            "or corrupted data (#{e.message})"
+            end
+
+            raise
+          end
+
+          # Map entries to their folders/streams
+          map_entries_to_streams
+        end
+
+        # Decrypt encrypted header
+        #
+        # @param encrypted_data [String] Encrypted header bytes
+        # @return [String] Decrypted header data
+        # @raise [RuntimeError] if password not provided
+        def decrypt_header(encrypted_data)
+          # Parse encrypted header structure
+          @encrypted_header = EncryptedHeader.from_binary(encrypted_data)
+
+          unless @password
+            raise Omnizip::PasswordError, "Archive headers are encrypted. Password required to access."
+          end
+
+          # Decrypt using password
+          encryptor = HeaderEncryptor.new(@password)
+          decrypted = encryptor.decrypt(
+            @encrypted_header.encrypted_data,
+            @encrypted_header.salt,
+            @encrypted_header.iv,
+          )
+          # AES-CBC 'succeeds' with any key and yields garbage; wrong
+          # passwords surface as later header-parse failures, so mark
+          # the archive and translate those into the password error
+          @headers_decrypted = true
+          decrypted
+        rescue OpenSSL::Cipher::CipherError => e
+          raise Omnizip::PasswordError, "Failed to decrypt headers: incorrect password (#{e.message})"
+        end
+
+        # Decompress encoded (compressed) header
+        #
+        # @param io [IO] Archive file handle
+        # @param encoded_data [String] Encoded header bytes
+        # @return [String] Decompressed header data
+        def decompress_encoded_header(io, encoded_data)
+          # Skip ENCODED_HEADER marker
+          parser = Parser.new(encoded_data[1..])
+
+          # Parse the streams info for the encoded header
+          stream_info = Models::StreamInfo.new
+
+          # Read streams info - can be either MAIN_STREAMS_INFO or direct stream properties
+          type = parser.read_byte
+
+          if type == PropertyId::MAIN_STREAMS_INFO
+            parse_streams_info(parser, stream_info)
+          elsif type == PropertyId::PACK_INFO
+            # Direct PackInfo without MAIN_STREAMS_INFO wrapper
+            parser.read_pack_info(stream_info)
+
+            # Read UNPACK_INFO
+            type = parser.read_byte
+            if type == PropertyId::UNPACK_INFO
+              parser.read_unpack_info(stream_info)
+            end
+          else
+            raise Omnizip::InvalidArchiveError, "Unexpected property in encoded header: 0x#{type.to_s(16)}"
+          end
+
+          # Decompress the header using the stream info
+          # For embedded archives, add offset to get absolute file position
+          pack_pos = @offset + @header.start_pos_after_header + stream_info.pack_pos
+          folder = stream_info.folders[0]
+          pack_size = stream_info.pack_sizes[0]
+          unpack_size = folder.uncompressed_size
+
+          decompressor = StreamDecompressor.new(io, folder, pack_pos, pack_size)
+          decompressor.decompress(unpack_size)
+        end
+
+        # Parse archive metadata
+        #
+        # @param parser [Parser] Parser instance
+        # @return [Array<StreamInfo, Array<Models::FileEntry>>] Parsed data
+        def parse_metadata(parser)
+          stream_info = Models::StreamInfo.new
+          entries = []
+
+          # Read main header
+          type = parser.read_byte
+          raise Omnizip::InvalidArchiveError, "Expected Header, got 0x#{type.to_s(16)}" unless
+            type == PropertyId::HEADER
+
+          # Parse header sections
+          until parser.eof?
+            prop_type = parser.read_byte
+
+            case prop_type
+            when PropertyId::MAIN_STREAMS_INFO
+              parse_streams_info(parser, stream_info)
+            when PropertyId::FILES_INFO
+              entries = parser.read_files_info
+            when PropertyId::K_END
+              break
+            else
+              # Skip unknown properties
+              parser.skip_data if !parser.eof? &&
+                parser.peek_byte != PropertyId::K_END
+            end
+          end
+
+          parser.read_byte if !parser.eof? &&
+            parser.peek_byte == PropertyId::K_END
+
+          [stream_info, entries]
+        end
+
+        # Parse streams info section
+        #
+        # @param parser [Parser] Parser instance
+        # @param stream_info [Models::StreamInfo] Stream info to populate
+        def parse_streams_info(parser, stream_info)
+          until parser.eof?
+            prop_type = parser.read_byte
+
+            case prop_type
+            when PropertyId::PACK_INFO
+              parser.read_pack_info(stream_info)
+            when PropertyId::UNPACK_INFO
+              parser.read_unpack_info(stream_info)
+            when PropertyId::SUBSTREAMS_INFO
+              parser.read_substreams_info(stream_info)
+            when PropertyId::K_END
+              break
+            else
+              # Unknown property within streams_info - skip it
+              parser.skip_data if !parser.eof? && parser.peek_byte != PropertyId::K_END
+            end
+          end
+
+          # Consume final K_END for MAIN_STREAMS_INFO section
+          parser.read_byte if !parser.eof? && parser.peek_byte == PropertyId::K_END
+        end
+
+        # Map entries to their folders and streams
+        def map_entries_to_streams
+          return if @stream_info.nil?
+
+          stream_idx = 0
+          @entries.each_with_index do |entry, i|
+            next unless entry.has_stream?
+
+            # Find which folder this stream belongs to
+            folder_idx = 0
+            accumulated = 0
+            @stream_info.num_unpack_streams_in_folders.each_with_index do |num, fi|
+              if stream_idx < accumulated + num
+                folder_idx = fi
+                break
+              end
+              accumulated += num
+            end
+
+            entry.folder_index = folder_idx
+            entry.file_index = i
+            entry.size = @stream_info.unpack_sizes[stream_idx] if @stream_info.unpack_sizes[stream_idx]
+
+            # Single-stream folders own their packed bytes outright,
+            # so the entry's compressed size is exact. Solid folders
+            # share packed bytes across streams — leave nil rather
+            # than fabricate a split.
+            num_in_folder = @stream_info.num_unpack_streams_in_folders[folder_idx]
+            if num_in_folder == 1
+              folder = @stream_info.folders[folder_idx]
+              packed = folder.pack_stream_indices.sum do |pi|
+                @stream_info.pack_sizes[pi] || 0
+              end
+              entry.compressed_size = packed
+            end
+
+            stream_idx += 1
+          end
+        end
+
+        # Extract entry data (private implementation)
+        #
+        # @param io [IO] Archive file handle
+        # @param entry [Models::FileEntry] Entry to extract
+        # @return [String] Extracted data
+        def extract_entry_data_private(io, entry)
+          return "" unless entry.has_stream?
+          return "" unless @stream_info
+
+          folder = @stream_info.folders[entry.folder_index]
+          return "" unless folder
+
+          # Calculate pack position (add offset for embedded archives)
+          pack_pos = @offset + @header.start_pos_after_header +
+            @stream_info.pack_pos
+
+          # Get pack sizes for this folder
+          pack_idx = 0
+          entry.folder_index.times do |i|
+            num_streams = @stream_info.folders[i].pack_stream_indices.size
+            pack_idx += num_streams
+          end
+
+          # Pack streams are laid out sequentially; skip past every
+          # stream owned by earlier folders to reach this folder's
+          # bytes (with stored archives pack sizes equal unpack
+          # sizes, which masked this offset in the past)
+          pack_idx.times { |i| pack_pos += @stream_info.pack_sizes[i] || 0 }
+
+          # Check if this is a BCJ2 multi-stream folder
+          if Bcj2StreamDecompressor.bcj2_folder?(folder)
+            extract_bcj2_entry(io, entry, folder, pack_pos, pack_idx)
+          else
+            extract_regular_entry(io, entry, folder, pack_pos, pack_idx)
+          end
+        rescue StandardError => e
+          warn "Extraction failed for #{entry.name}: #{e.message}"
+          raise
+        end
+
+        # Extract entry from BCJ2 multi-stream folder
+        #
+        # @param io [IO] Archive file handle
+        # @param entry [Models::FileEntry] Entry to extract
+        # @param folder [Models::Folder] Folder specification
+        # @param pack_pos [Integer] Base pack position
+        # @param pack_idx [Integer] Starting pack index
+        # @return [String] Extracted data
+        def extract_bcj2_entry(io, entry, folder, pack_pos, pack_idx)
+          # Cache solid block to avoid re-decompressing for every file
+          full_data = @solid_cache[entry.folder_index]
+
+          unless full_data
+            # BCJ2 folders have multiple pack streams
+            num_pack_streams = folder.pack_stream_indices.size
+            pack_sizes = Array.new(num_pack_streams) do |i|
+              @stream_info.pack_sizes[pack_idx + i] || 0
+            end
+
+            # Decompress the entire BCJ2 folder
+            decompressor = Bcj2StreamDecompressor.new(
+              io, folder, pack_pos, pack_sizes, @stream_info
+            )
+            full_data = decompressor.decompress(folder.uncompressed_size)
+
+            # Cache for other entries in the same folder
+            num_files_in_folder = @stream_info.num_unpack_streams_in_folders[entry.folder_index] || 1
+            if num_files_in_folder > 1
+              @solid_cache[entry.folder_index] = full_data
+              @solid_cache_extracted[entry.folder_index] = Set.new
+            end
+          end
+
+          # For solid archives, extract this file's portion
+          num_files_in_folder = @stream_info.num_unpack_streams_in_folders[entry.folder_index] || 1
+
+          if num_files_in_folder > 1
+            # Find offset of this file within the uncompressed stream
+            file_offset = 0
+            @entries.each do |e|
+              break if e.file_index == entry.file_index
+
+              file_offset += e.size if e.has_stream? && e.folder_index == entry.folder_index
+            end
+            data = full_data[file_offset, entry.size]
+          else
+            data = full_data[0, entry.size]
+          end
+
+          # Verify CRC if available
+          if entry.crc
+            crc = Omnizip::Checksums::Crc32.new
+            crc.update(data)
+            unless crc.value == entry.crc
+              raise Omnizip::ChecksumError, "CRC mismatch for #{entry.name}: expected 0x#{entry.crc.to_s(16)}, got 0x#{crc.value.to_s(16)}"
+            end
+          end
+
+          # Evict solid cache entry when all files in folder have been extracted
+          if @solid_cache_extracted.key?(entry.folder_index)
+            @solid_cache_extracted[entry.folder_index].add(entry.file_index)
+            if @solid_cache_extracted[entry.folder_index].size >= num_files_in_folder
+              @solid_cache.delete(entry.folder_index)
+              @solid_cache_extracted.delete(entry.folder_index)
+            end
+          end
+
+          data
+        end
+
+        # Extract entry from regular (non-BCJ2) folder
+        #
+        # @param io [IO] Archive file handle
+        # @param entry [Models::FileEntry] Entry to extract
+        # @param folder [Models::Folder] Folder specification
+        # @param pack_pos [Integer] Base pack position
+        # @param pack_idx [Integer] Starting pack index
+        # @return [String] Extracted data
+        def extract_regular_entry(io, entry, folder, pack_pos, pack_idx)
+          pack_size = @stream_info.pack_sizes[pack_idx] || 0
+
+          # For solid archives, multiple files share one compressed stream
+          # We need to decompress the entire folder and extract the correct portion
+          num_files_in_folder = @stream_info.num_unpack_streams_in_folders[entry.folder_index] || 1
+
+          if num_files_in_folder > 1
+            # Cache solid block to avoid re-decompressing for every file
+            full_data = @solid_cache[entry.folder_index]
+
+            unless full_data
+              total_unpack_size = folder.uncompressed_size
+              decompressor = StreamDecompressor.new(io, folder, pack_pos,
+                                                    pack_size)
+              full_data = decompressor.decompress(total_unpack_size)
+              @solid_cache[entry.folder_index] = full_data
+              @solid_cache_extracted[entry.folder_index] = Set.new
+            end
+
+            # Find offset of this file within the uncompressed stream
+            file_offset = 0
+            @entries.each do |e|
+              break if e.file_index == entry.file_index
+
+              file_offset += e.size if e.has_stream? && e.folder_index == entry.folder_index
+            end
+
+            # Extract this file's data
+            data = full_data[file_offset, entry.size]
+
+            # Verify CRC if available
+            if entry.crc
+              crc = Omnizip::Checksums::Crc32.new
+              crc.update(data)
+              unless crc.value == entry.crc
+                raise Omnizip::ChecksumError, "CRC mismatch for #{entry.name}: expected 0x#{entry.crc.to_s(16)}, got 0x#{crc.value.to_s(16)}"
+              end
+            end
+
+            # Evict solid cache entry when all files in folder have been extracted
+            if @solid_cache_extracted.key?(entry.folder_index)
+              @solid_cache_extracted[entry.folder_index].add(entry.file_index)
+              if @solid_cache_extracted[entry.folder_index].size >= num_files_in_folder
+                @solid_cache.delete(entry.folder_index)
+                @solid_cache_extracted.delete(entry.folder_index)
+              end
+            end
+
+            data
+          else
+            # Non-solid: each file has its own compressed stream
+            decompressor = StreamDecompressor.new(io, folder, pack_pos,
+                                                  pack_size)
+            expected_crc = entry.crc
+            decompressor.decompress_and_verify(entry.size, expected_crc)
+          end
+        end
+
+        # Check if file path indicates a split archive
+        #
+        # @return [Boolean] true if appears to be split
+        def split_archive?
+          # Numeric pattern: .001, .002, etc.
+          return true if /\.\d{3}$/.match?(@file_path)
+
+          # Alpha pattern: .7z.aa, .tar.ab, etc. (but not .7z, .tar, .zip alone)
+          # Must have a known archive extension followed by alpha suffix
+          return true if /\.(7z|tar|zip|rar)\.[a-z]{2,}$/.match?(@file_path)
+
+          false
+        end
+      end
+    end
+  end
+end