omnizip 0.3.1

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

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      # RAR parity operations handler
+      # Reads parity data and performs recovery calculations
+      class ParityHandler
+        attr_reader :recovery_record, :parity_blocks
+
+        # Initialize parity handler
+        #
+        # @param recovery_record [RecoveryRecord] Recovery record instance
+        def initialize(recovery_record)
+          @recovery_record = recovery_record
+          @parity_blocks = []
+        end
+
+        # Load parity data from .rev files
+        #
+        # @param rev_files [Array<String>] Paths to .rev files
+        # @return [Boolean] true if loaded successfully
+        def load_parity_data(rev_files)
+          @parity_blocks = []
+
+          rev_files.each do |rev_file|
+            blocks = parse_rev_file(rev_file)
+            @parity_blocks.concat(blocks) if blocks
+          end
+
+          @parity_blocks.any?
+        end
+
+        # Verify archive blocks using parity
+        #
+        # @param archive_path [String] Path to archive
+        # @param block_indices [Array<Integer>] Blocks to verify
+        # @return [Hash] Verification results
+        def verify_blocks(archive_path, block_indices = nil)
+          if @parity_blocks.empty?
+            return { verified: false,
+                     error: "No parity data" }
+          end
+
+          blocks_to_check = block_indices || (0...total_blocks).to_a
+          corrupted_blocks = []
+
+          blocks_to_check.each do |index|
+            corrupted_blocks << index unless verify_block(archive_path, index)
+          end
+
+          {
+            verified: corrupted_blocks.empty?,
+            total: blocks_to_check.size,
+            ok: blocks_to_check.size - corrupted_blocks.size,
+            corrupted: corrupted_blocks,
+          }
+        end
+
+        # Calculate parity for a block
+        #
+        # @param data [String] Binary data
+        # @param block_index [Integer] Block index
+        # @return [String] Parity data
+        def calculate_parity(data, block_index)
+          # Basic XOR parity for simple recovery
+          # In production, would use Reed-Solomon
+          parity = data.bytes.reduce(0) { |acc, byte| acc ^ byte }
+          [parity, block_index].pack("CN")
+        end
+
+        # Recover corrupted block
+        #
+        # @param archive_path [String] Path to archive
+        # @param block_index [Integer] Block to recover
+        # @return [String, nil] Recovered data or nil
+        def recover_block(archive_path, block_index)
+          return nil unless can_recover?(block_index)
+
+          if @recovery_record.version == 5
+            recover_rar5_block(archive_path, block_index)
+          else
+            recover_rar4_block(archive_path, block_index)
+          end
+        end
+
+        # Check if block can be recovered
+        #
+        # @param block_index [Integer] Block index
+        # @return [Boolean] true if recoverable
+        def can_recover?(block_index)
+          return false if @parity_blocks.empty?
+
+          # Can recover if we have parity data for this block
+          @parity_blocks.any? { |p| p[:index] == block_index }
+        end
+
+        # Get total number of blocks
+        #
+        # @return [Integer] Total blocks
+        def total_blocks
+          return 0 if @recovery_record.block_size.zero?
+
+          (@recovery_record.protected_size / @recovery_record.block_size.to_f).ceil
+        end
+
+        # Get parity block by index
+        #
+        # @param index [Integer] Block index
+        # @return [Hash, nil] Parity block data
+        def parity_block(index)
+          @parity_blocks.find { |p| p[:index] == index }
+        end
+
+        private
+
+        # Parse .rev file
+        #
+        # @param rev_file [String] Path to .rev file
+        # @return [Array<Hash>, nil] Parity blocks
+        def parse_rev_file(rev_file)
+          return nil unless File.exist?(rev_file)
+
+          blocks = []
+
+          File.open(rev_file, "rb") do |io|
+            # Check RAR signature in .rev file
+            signature = io.read(7)
+            return nil unless valid_rev_signature?(signature)
+
+            # Parse recovery blocks
+            until io.eof?
+              block = parse_parity_block(io)
+              break unless block
+
+              blocks << block
+            end
+          end
+
+          blocks
+        rescue StandardError
+          nil
+        end
+
+        # Check if valid .rev file signature
+        #
+        # @param signature [String] File signature
+        # @return [Boolean] true if valid
+        def valid_rev_signature?(signature)
+          return false unless signature
+
+          bytes = signature.bytes
+          bytes[0..3] == [0x52, 0x61, 0x72, 0x21] # "Rar!"
+        end
+
+        # Parse parity block from .rev file
+        #
+        # @param io [IO] Input stream
+        # @return [Hash, nil] Parity block data
+        def parse_parity_block(io)
+          # Read block header
+          block_size = io.read(4)&.unpack1("V")
+          return nil unless block_size
+
+          block_index = io.read(4)&.unpack1("V")
+          checksum = io.read(4)&.unpack1("V")
+
+          # Read parity data
+          parity_data = io.read(block_size - 12)
+          return nil unless parity_data
+
+          {
+            index: block_index,
+            size: block_size,
+            checksum: checksum,
+            data: parity_data,
+          }
+        rescue StandardError
+          nil
+        end
+
+        # Verify single block
+        #
+        # @param archive_path [String] Path to archive
+        # @param block_index [Integer] Block index
+        # @return [Boolean] true if block is valid
+        def verify_block(archive_path, block_index)
+          parity = parity_block(block_index)
+          return true unless parity # No parity, assume OK
+
+          # Read block from archive
+          block_data = read_archive_block(archive_path, block_index)
+          return false unless block_data
+
+          # Calculate checksum
+          calculated = calculate_block_checksum(block_data)
+          calculated == parity[:checksum]
+        end
+
+        # Read block from archive
+        #
+        # @param archive_path [String] Path to archive
+        # @param block_index [Integer] Block index
+        # @return [String, nil] Block data
+        def read_archive_block(archive_path, block_index)
+          return nil unless File.exist?(archive_path)
+
+          block_size = @recovery_record.block_size
+          offset = block_index * block_size
+
+          File.open(archive_path, "rb") do |io|
+            io.seek(offset)
+            io.read(block_size)
+          end
+        rescue StandardError
+          nil
+        end
+
+        # Calculate block checksum
+        #
+        # @param data [String] Block data
+        # @return [Integer] CRC32 checksum
+        def calculate_block_checksum(data)
+          Zlib.crc32(data)
+        end
+
+        # Recover RAR5 block using Reed-Solomon
+        #
+        # @param archive_path [String] Path to archive
+        # @param block_index [Integer] Block index
+        # @return [String, nil] Recovered data
+        def recover_rar5_block(archive_path, block_index)
+          parity = parity_block(block_index)
+          return nil unless parity
+
+          # Read corrupted block
+          block_data = read_archive_block(archive_path, block_index)
+          return nil unless block_data
+
+          # Use Reed-Solomon decoding
+          # This is a placeholder - real implementation would use
+          # reed-solomon gem or similar
+          recover_with_reed_solomon(block_data, parity[:data])
+        end
+
+        # Recover RAR4 block using old recovery method
+        #
+        # @param archive_path [String] Path to archive
+        # @param block_index [Integer] Block index
+        # @return [String, nil] Recovered data
+        def recover_rar4_block(archive_path, block_index)
+          parity = parity_block(block_index)
+          return nil unless parity
+
+          # Read corrupted block
+          block_data = read_archive_block(archive_path, block_index)
+          return nil unless block_data
+
+          # Simple XOR recovery for RAR4
+          recover_with_xor(block_data, parity[:data])
+        end
+
+        # Recover data using Reed-Solomon (RAR5)
+        #
+        # @param corrupted_data [String] Corrupted block
+        # @param parity_data [String] Parity information
+        # @return [String, nil] Recovered data
+        def recover_with_reed_solomon(_corrupted_data, _parity_data)
+          # Placeholder for Reed-Solomon recovery
+          # Real implementation would use reed-solomon gem
+          # For now, return nil to indicate recovery not available
+          nil
+        end
+
+        # Recover data using XOR (RAR4)
+        #
+        # @param corrupted_data [String] Corrupted block
+        # @param parity_data [String] Parity information
+        # @return [String] Recovered data
+        def recover_with_xor(corrupted_data, parity_data)
+          # Simple XOR recovery
+          result = corrupted_data.bytes.map.with_index do |byte, i|
+            parity_byte = parity_data.bytes[i % parity_data.size]
+            byte ^ parity_byte
+          end
+
+          result.pack("C*")
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/rar5/compression/lzma.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../../../../algorithms/lzma"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module Compression
+          # LZMA compression method for RAR5
+          #
+          # This adapter uses the existing LZMA implementation with
+          # RAR5-specific parameters and encoding.
+          #
+          # RAR5 compression methods (from spec):
+          # - 0: STORE (no compression)
+          # - 1: FASTEST
+          # - 2: FAST
+          # - 3: NORMAL
+          # - 4: GOOD
+          # - 5: BEST
+          #
+          # For methods 1-5, RAR5 uses LZMA compression with different
+          # dictionary sizes and compression levels.
+          #
+          # @example Compress data with LZMA
+          #   compressed = Lzma.compress("Hello, World!", level: 5)
+          class Lzma
+            # Compression method identifier for RAR5
+            # Methods 1-5 all use LZMA with different parameters
+            METHOD_FASTEST = 1
+            METHOD_FAST = 2
+            METHOD_NORMAL = 3
+            METHOD_GOOD = 4
+            METHOD_BEST = 5
+
+            # Compress data using LZMA
+            #
+            # @param data [String] Data to compress
+            # @param options [Hash] Compression options
+            # @option options [Integer] :level Compression level (1-5, default: 3)
+            # @return [Hash] Hash with :data (compressed) and :properties (9 bytes for extra area)
+            def self.compress(data, options = {})
+              level = options[:level] || METHOD_NORMAL
+
+              # Create StringIO streams for LZMA
+              input = StringIO.new(data)
+              output = StringIO.new
+              output.set_encoding(Encoding::BINARY)
+
+              # Create LZMA encoder with RAR5-appropriate settings
+              lzma = Algorithms::LZMA.new
+              lzma_options = build_lzma_options(level)
+
+              # Build encoder options hash that LZMA encoder will accept
+              encoder_options = {
+                dict_size: lzma_options.dict_size,
+                lc: lzma_options.lc,
+                lp: lzma_options.lp,
+                pb: lzma_options.pb,
+                level: level,
+              }
+
+              # Compress using LZMA with RAR5 parameters
+              lzma.compress(input, output, encoder_options)
+
+              # The LZMA encoder outputs:
+              #   - 1 byte: properties (lc, lp, pb)
+              #   - 4 bytes: dictionary size (little-endian)
+              #   - 8 bytes: uncompressed size (little-endian)
+              #   - remaining: compressed data
+              #
+              # RAR5 stores properties in file header extra area (type 0x03),
+              # so we extract them separately
+              compressed_with_header = output.string
+
+              if compressed_with_header.bytesize > 13
+                # Extract LZMA properties for RAR5 extra area
+                # RAR5 stores: property byte (1) + dict size (4) = 5 bytes
+                # NOT the uncompressed size (which is in the next 8 bytes of LZMA header)
+                properties = compressed_with_header[0, 5]
+
+                # Extract raw LZMA stream (skip 13-byte header)
+                compressed_data = compressed_with_header[13..]
+
+                {
+                  data: compressed_data,
+                  properties: properties,
+                }
+              else
+                # Edge case: if compression produced less than 13 bytes (extremely rare),
+                # return original data uncompressed with nil properties
+                warn "LZMA output too small (#{compressed_with_header.bytesize} bytes), using STORE"
+                {
+                  data: data,
+                  properties: nil,
+                }
+              end
+            end
+
+            # Decompress LZMA-compressed data
+            #
+            # @param data [String] Compressed data (raw LZMA stream without header)
+            # @param options [Hash] Decompression options
+            # @option options [String] :properties The 5-byte properties from compress (property byte + dict size)
+            # @option options [Integer] :uncompressed_size Expected uncompressed size (optional, for EOS marker mode)
+            # @return [String] Decompressed data
+            def self.decompress(data, options = {})
+              properties = options[:properties]
+              uncompressed_size = options[:uncompressed_size]
+
+              # Reconstruct the 13-byte LZMA header if properties are provided
+              if properties && properties.bytesize >= 5
+                # properties contains: 1 byte props + 4 bytes dict size
+                # We need to add 8 bytes for uncompressed size
+                header = properties.dup
+                header += if uncompressed_size
+                            # Add uncompressed size as 8-byte little-endian
+                            [uncompressed_size].pack("Q<")
+                          else
+                            # Use -1 (0xFFFFFFFFFFFFFFFF) to indicate EOS marker mode
+                            [0xFFFFFFFFFFFFFFFF].pack("Q<")
+                          end
+                full_data = header + data
+              else
+                # Assume data already has header (backward compatibility)
+                full_data = data
+              end
+
+              input = StringIO.new(full_data)
+              output = StringIO.new
+              output.set_encoding(Encoding::BINARY)
+
+              # Use SDK decoder since RAR5 LZMA was compressed with SDK encoder
+              require_relative "../../../../implementations/seven_zip/lzma/decoder"
+              decoder = Implementations::SevenZip::LZMA::Decoder.new(input)
+              decoder.decode_stream(output)
+
+              output.string
+            end
+
+            # Get compression method identifier for level
+            #
+            # @param level [Integer] Compression level (1-5)
+            # @return [Integer] Method ID
+            def self.method_id(level = METHOD_NORMAL)
+              level.clamp(METHOD_FASTEST, METHOD_BEST)
+            end
+
+            # Get compression info VINT value
+            #
+            # For RAR5, compression_info encodes:
+            # - Bits 0-5: compression method (1-5 for LZMA)
+            # - Bits 6+: version (0 for now)
+            #
+            # @param level [Integer] Compression level (1-5)
+            # @return [Integer] Compression info value
+            def self.compression_info(level = METHOD_NORMAL)
+              method = method_id(level)
+              method & 0x3F # Bits 0-5 only
+            end
+
+            # Build LZMA options based on RAR5 compression level
+            #
+            # @param level [Integer] RAR5 compression level (1-5)
+            # @return [LzmaOptions] LZMA encoder options object
+            def self.build_lzma_options(level)
+              # RAR5 compression levels map to LZMA parameters
+              # These are approximations based on typical RAR behavior
+              dict_size = 1 << case level
+                               when 1 then 18  # 256 KB (fastest)
+                               when 2 then 20  # 1 MB (fast)
+                               when 3 then 22  # 4 MB (normal)
+                               when 4 then 23  # 8 MB (good)
+                               when 5 then 24  # 16 MB (best)
+                               else 22 # default: 4 MB
+                               end
+
+              # RAR5 uses specific LZMA parameters: lc=1, lp=2, pb=0
+              # (Different from standalone LZMA which typically uses lc=3, lp=0, pb=2)
+              LzmaOptions.new(level, dict_size, lc: 1, lp: 2, pb: 0)
+            end
+
+            # Simple options class for LZMA parameters
+            class LzmaOptions
+              attr_reader :level, :dict_size, :lc, :lp, :pb
+
+              def initialize(level, dict_size, lc: 3, lp: 0, pb: 2)
+                @level = level
+                @dict_size = dict_size
+                @lc = lc
+                @lp = lp
+                @pb = pb
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end