omnizip 0.3.1

data/lib/omnizip/formats/rar/archive_verifier.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative "recovery_record"
+require_relative "parity_handler"
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR archive verification
+      # Verifies archive integrity using CRCs and recovery records
+      class ArchiveVerifier
+        attr_reader :archive_path, :recovery_record, :parity_handler
+
+        # Verification result
+        class VerificationResult
+          attr_accessor :valid, :files_total, :files_ok, :files_corrupted,
+                        :corrupted_files, :recoverable, :corrupt_blocks,
+                        :recovery_available, :errors
+
+          def initialize
+            @valid = true
+            @files_total = 0
+            @files_ok = 0
+            @files_corrupted = 0
+            @corrupted_files = []
+            @recoverable = false
+            @corrupt_blocks = []
+            @recovery_available = false
+            @errors = []
+          end
+
+          # Check if archive is valid
+          #
+          # @return [Boolean] true if valid
+          def valid?
+            @valid && @files_corrupted.zero?
+          end
+
+          # Check if corruption can be repaired
+          #
+          # @return [Boolean] true if repairable
+          def can_repair?
+            @recovery_available && @recoverable
+          end
+
+          # Get summary string
+          #
+          # @return [String] Verification summary
+          def summary
+            if valid?
+              "Archive OK: #{@files_total} files verified"
+            else
+              msg = "Archive corrupted: #{@files_corrupted}/#{@files_total} files damaged"
+              msg += " (repairable)" if can_repair?
+              msg
+            end
+          end
+        end
+
+        # Initialize verifier
+        #
+        # @param archive_path [String] Path to RAR archive
+        def initialize(archive_path)
+          @archive_path = archive_path
+          @recovery_record = nil
+          @parity_handler = nil
+        end
+
+        # Verify archive integrity
+        #
+        # @param use_recovery [Boolean] Use recovery records for verification
+        # @param verbose [Boolean] Enable verbose output
+        # @return [VerificationResult] Verification results
+        def verify(use_recovery: true, verbose: false)
+          result = VerificationResult.new
+
+          begin
+            # Open and parse archive
+            reader = Reader.new(@archive_path)
+            reader.open
+
+            result.files_total = reader.entries.size
+
+            # Detect recovery records
+            detect_recovery_records(reader, result) if use_recovery
+
+            # Verify each file
+            reader.entries.each do |entry|
+              file_valid = verify_entry(entry, verbose)
+
+              if file_valid
+                result.files_ok += 1
+              else
+                result.files_corrupted += 1
+                result.corrupted_files << entry.name
+                result.valid = false
+              end
+            end
+
+            # Check if corruption is recoverable
+            if result.files_corrupted.positive? && result.recovery_available
+              result.recoverable = check_recoverability(result.corrupt_blocks)
+            end
+          rescue StandardError => e
+            result.valid = false
+            result.errors << "Verification failed: #{e.message}"
+          end
+
+          result
+        end
+
+        # Verify single file entry
+        #
+        # @param entry [Models::RarEntry] Entry to verify
+        # @param verbose [Boolean] Print verbose output
+        # @return [Boolean] true if valid
+        def verify_entry(entry, verbose = false)
+          return true if entry.directory?
+
+          # For now, we rely on the decompressor to verify
+          # In a full implementation, we would check CRC32
+          valid = verify_entry_crc(entry)
+
+          puts "#{entry.name}: #{valid ? 'OK' : 'FAILED'}" if verbose
+
+          valid
+        rescue StandardError => e
+          puts "#{entry.name}: ERROR (#{e.message})" if verbose
+          false
+        end
+
+        # Quick test of archive
+        #
+        # @return [Boolean] true if archive can be opened
+        def quick_test
+          Reader.new(@archive_path).open
+          true
+        rescue StandardError
+          false
+        end
+
+        private
+
+        # Detect recovery records in archive
+        #
+        # @param reader [Reader] Archive reader
+        # @param result [VerificationResult] Result object to update
+        def detect_recovery_records(reader, result)
+          version = reader.header&.version || 4
+
+          @recovery_record = RecoveryRecord.new(version)
+
+          # Check for integrated recovery records
+          File.open(@archive_path, "rb") do |io|
+            @recovery_record.parse_from_archive(io, reader.archive_info.flags)
+          end
+
+          # Check for external .rev files
+          rev_files = @recovery_record.detect_external_files(@archive_path)
+          @recovery_record.load_external_files(rev_files) if rev_files.any?
+
+          result.recovery_available = @recovery_record.available?
+
+          # Initialize parity handler if recovery available
+          return unless result.recovery_available
+
+          @parity_handler = ParityHandler.new(@recovery_record)
+          @parity_handler.load_parity_data(@recovery_record.external_files)
+        end
+
+        # Verify entry CRC
+        #
+        # @param entry [Models::RarEntry] Entry to verify
+        # @return [Boolean] true if CRC matches
+        def verify_entry_crc(_entry)
+          # This is a placeholder - actual CRC verification would require
+          # extracting and checking the file
+          # For now, assume OK unless we have specific corruption data
+          true
+        end
+
+        # Check if corruption is recoverable
+        #
+        # @param corrupt_blocks [Array<Integer>] Corrupted block indices
+        # @return [Boolean] true if recoverable
+        def check_recoverability(corrupt_blocks)
+          return false unless @parity_handler
+
+          # Check if all corrupted blocks can be recovered
+          corrupt_blocks.all? { |idx| @parity_handler.can_recover?(idx) }
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/block_parser.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "models/rar_entry"
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR block parser
+      # Parses different block types in RAR archives
+      class BlockParser
+        include Constants
+
+        attr_reader :version
+
+        # Initialize block parser
+        #
+        # @param version [Integer] RAR version (4 or 5)
+        def initialize(version)
+          @version = version
+        end
+
+        # Parse file block and create entry
+        #
+        # @param io [IO] Input stream
+        # @return [Models::RarEntry, nil] Parsed entry or nil
+        def parse_file_block(io)
+          if @version == 5
+            parse_rar5_file_block(io)
+          else
+            parse_rar4_file_block(io)
+          end
+        end
+
+        # Skip to next block
+        #
+        # @param io [IO] Input stream
+        # @param block_size [Integer] Block size to skip
+        def skip_block(io, block_size)
+          io.read(block_size) if block_size.positive?
+        end
+
+        private
+
+        # Parse RAR4 file block
+        #
+        # @param io [IO] Input stream
+        # @return [Models::RarEntry, nil] Parsed entry or nil
+        def parse_rar4_file_block(io)
+          entry = Models::RarEntry.new
+
+          # Read block header
+          read_uint16(io)
+          head_type = io.read(1)&.ord
+          return nil unless head_type == BLOCK_FILE
+
+          head_flags = read_uint16(io)
+          head_size = read_uint16(io)
+
+          # Read file header data
+          pack_size = read_uint32(io)
+          unpack_size = read_uint32(io)
+          host_os = io.read(1)&.ord
+          file_crc = read_uint32(io)
+          file_time = read_uint32(io)
+          unpack_ver = io.read(1)&.ord
+          method = io.read(1)&.ord
+          name_size = read_uint16(io)
+          attr = read_uint32(io)
+
+          # Read extended sizes if large file
+          if head_flags.anybits?(FILE_LARGE)
+            high_pack_size = read_uint32(io)
+            high_unpack_size = read_uint32(io)
+            pack_size |= (high_pack_size << 32)
+            unpack_size |= (high_unpack_size << 32)
+          end
+
+          # Read file name
+          name_bytes = io.read(name_size)
+          entry.name = decode_filename(name_bytes, head_flags)
+
+          # Set entry properties
+          entry.size = unpack_size
+          entry.compressed_size = pack_size
+          entry.crc = file_crc
+          entry.host_os = host_os
+          entry.method = method
+          entry.version = unpack_ver
+          entry.flags = head_flags
+          entry.attributes = attr
+          entry.mtime = dos_time_to_time(file_time)
+
+          # Set flags
+          entry.is_dir = head_flags.anybits?(FILE_DIRECTORY)
+          entry.encrypted = head_flags.anybits?(FILE_ENCRYPTED)
+          entry.split_before = head_flags.anybits?(FILE_SPLIT_BEFORE)
+          entry.split_after = head_flags.anybits?(FILE_SPLIT_AFTER)
+
+          # Skip remaining header data and file data
+          # Fixed fields: TYPE(1) + FLAGS(2) + SIZE(2) + PACK_SIZE(4) + UNPACK_SIZE(4) +
+          #               HOST_OS(1) + FILE_CRC(4) + FILE_TIME(4) + VERSION(1) + METHOD(1) +
+          #               NAME_SIZE(2) + ATTR(4) = 30 bytes
+          remaining = head_size - (name_size + 30)
+          remaining += 8 if head_flags.anybits?(FILE_LARGE)
+          io.read(remaining) if remaining.positive?
+          io.read(pack_size) # Skip compressed data
+
+          entry
+        end
+
+        # Parse RAR5 file block
+        #
+        # @param io [IO] Input stream
+        # @return [Models::RarEntry, nil] Parsed entry or nil
+        def parse_rar5_file_block(io)
+          entry = Models::RarEntry.new
+
+          # Read block header
+          read_uint32(io)
+          read_vint(io)
+          header_type = read_vint(io)
+          return nil unless header_type == RAR5_HEADER_FILE
+
+          header_flags = read_vint(io)
+
+          # Read file header
+          file_flags = read_vint(io)
+          unpack_size = read_vint(io)
+          attr = read_vint(io)
+
+          # Read modification time if present
+          mtime = nil
+          mtime = read_uint32(io) if file_flags.anybits?(0x02)
+
+          # Read CRC if present
+          crc = nil
+          crc = read_uint32(io) if file_flags.anybits?(0x04)
+
+          # Read compression info
+          read_vint(io)
+          host_os = read_vint(io)
+          name_length = read_vint(io)
+
+          # Read file name
+          name_bytes = io.read(name_length)
+          entry.name = name_bytes.force_encoding("UTF-8")
+
+          # Set entry properties
+          entry.size = unpack_size
+          entry.compressed_size = 0 # Not directly available in header
+          entry.crc = crc
+          entry.host_os = host_os
+          entry.flags = file_flags
+          entry.attributes = attr
+          entry.mtime = Time.at(mtime) if mtime
+          entry.is_dir = file_flags.anybits?(RAR5_FLAG_IS_DIR)
+          entry.version = 5
+
+          # Read extra area if present
+          if header_flags.anybits?(RAR5_FLAG_EXTRA_AREA)
+            extra_size = read_vint(io)
+            io.read(extra_size) if extra_size.positive?
+          end
+
+          # Read data area if present
+          if header_flags.anybits?(RAR5_FLAG_DATA_AREA)
+            data_size = read_vint(io)
+            io.read(data_size) if data_size.positive?
+          end
+
+          entry
+        end
+
+        # Decode filename from bytes
+        #
+        # @param bytes [String] Raw filename bytes
+        # @param flags [Integer] Block flags
+        # @return [String] Decoded filename
+        def decode_filename(bytes, flags)
+          if flags.nobits?(FILE_UNICODE)
+            # ASCII filename
+            bytes.force_encoding("ASCII-8BIT")
+          else
+            # Unicode filename
+            bytes.force_encoding("UTF-8")
+          end
+        end
+
+        # Convert DOS time to Ruby Time
+        #
+        # @param dos_time [Integer] DOS time value
+        # @return [Time] Ruby time object
+        def dos_time_to_time(dos_time)
+          sec = (dos_time & 0x1F) * 2
+          min = (dos_time >> 5) & 0x3F
+          hour = (dos_time >> 11) & 0x1F
+          day = (dos_time >> 16) & 0x1F
+          month = (dos_time >> 21) & 0x0F
+          year = ((dos_time >> 25) & 0x7F) + 1980
+
+          Time.new(year, month, day, hour, min, sec)
+        rescue ArgumentError
+          Time.now
+        end
+
+        # Read 16-bit unsigned integer (little-endian)
+        def read_uint16(io)
+          bytes = io.read(2)
+          return 0 unless bytes&.size == 2
+
+          bytes.unpack1("v")
+        end
+
+        # Read 32-bit unsigned integer (little-endian)
+        def read_uint32(io)
+          bytes = io.read(4)
+          return 0 unless bytes&.size == 4
+
+          bytes.unpack1("V")
+        end
+
+        # Read variable-length integer (RAR5)
+        def read_vint(io)
+          result = 0
+          shift = 0
+
+          loop do
+            byte = io.read(1)&.ord
+            return result unless byte
+
+            result |= (byte & 0x7F) << shift
+            break if byte.nobits?(0x80)
+
+            shift += 7
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/compression/bit_stream.rb

@@ -0,0 +1,180 @@
+# 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 Rar
+      module Compression
+        # Bit-level I/O stream for RAR compression algorithms
+        #
+        # Provides methods to read and write individual bits from byte streams.
+        # This is a shared utility used by PPMd, LZ77+Huffman, and other RAR
+        # compression algorithms that need bit-level access.
+        #
+        # Responsibilities:
+        # - ONE responsibility: Bit-level I/O operations
+        # - Read bits from byte stream
+        # - Write bits to byte stream
+        # - Manage bit buffer and byte alignment
+        class BitStream
+          # Initialize a new bit stream
+          #
+          # @param io [IO] The underlying byte stream
+          # @param mode [Symbol] :read or :write
+          def initialize(io, mode = :read)
+            @io = io
+            @mode = mode
+            @buffer = 0
+            @bits_in_buffer = 0
+          end
+
+          # Read specified number of bits
+          #
+          # @param count [Integer] Number of bits to read (1-32)
+          # @return [Integer] The bits read as an integer
+          def read_bits(count)
+            unless @mode == :read
+              raise ArgumentError,
+                    "Can only read in read mode"
+            end
+            raise ArgumentError, "Count must be 1-32" unless count.between?(1,
+                                                                            32)
+
+            result = 0
+
+            count.times do
+              result = (result << 1) | read_bit
+            end
+
+            result
+          end
+
+          # Read a single bit
+          #
+          # @return [Integer] 0 or 1
+          def read_bit
+            unless @mode == :read
+              raise ArgumentError,
+                    "Can only read in read mode"
+            end
+
+            if @bits_in_buffer.zero?
+              fill_buffer
+            end
+
+            @bits_in_buffer -= 1
+            (@buffer >> @bits_in_buffer) & 1
+          end
+
+          # Write specified number of bits
+          #
+          # @param value [Integer] The value to write
+          # @param count [Integer] Number of bits to write (1-32)
+          # @return [void]
+          def write_bits(value, count)
+            unless @mode == :write
+              raise ArgumentError,
+                    "Can only write in write mode"
+            end
+            raise ArgumentError, "Count must be 1-32" unless count.between?(1,
+                                                                            32)
+
+            count.times do |i|
+              bit = (value >> (count - 1 - i)) & 1
+              write_bit(bit)
+            end
+          end
+
+          # Write a single bit
+          #
+          # @param bit [Integer] 0 or 1
+          # @return [void]
+          def write_bit(bit)
+            unless @mode == :write
+              raise ArgumentError,
+                    "Can only write in write mode"
+            end
+
+            @buffer = (@buffer << 1) | (bit & 1)
+            @bits_in_buffer += 1
+
+            flush_buffer if @bits_in_buffer == 8
+          end
+
+          # Align to byte boundary (read mode)
+          #
+          # @return [void]
+          def align_to_byte
+            return unless @mode == :read
+
+            @bits_in_buffer = 0
+            @buffer = 0
+          end
+
+          # Flush any remaining bits (write mode)
+          #
+          # @return [void]
+          def flush
+            return unless @mode == :write
+            return if @bits_in_buffer.zero?
+
+            # Pad with zeros to complete byte
+            padding = 8 - @bits_in_buffer
+            @buffer <<= padding
+            @io.write([@buffer].pack("C"))
+            @buffer = 0
+            @bits_in_buffer = 0
+          end
+
+          # Check if at end of stream
+          #
+          # @return [Boolean] True if no more data available
+          def eof?
+            @mode == :read && @bits_in_buffer.zero? && @io.eof?
+          end
+
+          private
+
+          # Fill buffer with next byte from stream
+          #
+          # @return [void]
+          def fill_buffer
+            byte = @io.read(1)
+            raise EOFError, "Unexpected end of stream" if byte.nil?
+
+            @buffer = byte.unpack1("C")
+            @bits_in_buffer = 8
+          end
+
+          # Flush full buffer byte to stream
+          #
+          # @return [void]
+          def flush_buffer
+            @io.write([@buffer].pack("C"))
+            @buffer = 0
+            @bits_in_buffer = 0
+          end
+        end
+      end
+    end
+  end
+end