cabriolet 0.1.0

data/lib/cabriolet/validator.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  # Archive validation and integrity checking
+  class Validator
+    # Validation levels
+    LEVEL_QUICK = :quick        # Basic structure validation
+    LEVEL_STANDARD = :standard  # Standard validation with checksums
+    LEVEL_THOROUGH = :thorough  # Full decompression validation
+
+    def initialize(path, level: LEVEL_STANDARD)
+      @path = path
+      @level = level
+      @errors = []
+      @warnings = []
+      @format = nil
+    end
+
+    # Validate the archive
+    #
+    # @return [ValidationReport] Validation report object
+    #
+    # @example
+    #   validator = Cabriolet::Validator.new('archive.cab')
+    #   report = validator.validate
+    #   puts "Valid: #{report.valid?}"
+    #   puts "Errors: #{report.errors}"
+    def validate
+      detect_format
+
+      case @level
+      when LEVEL_QUICK
+        validate_quick
+      when LEVEL_STANDARD
+        validate_standard
+      when LEVEL_THOROUGH
+        validate_thorough
+      end
+
+      ValidationReport.new(
+        valid: @errors.empty?,
+        format: @format,
+        level: @level,
+        errors: @errors,
+        warnings: @warnings,
+        path: @path,
+      )
+    end
+
+    private
+
+    def detect_format
+      @format = FormatDetector.detect(@path)
+
+      unless @format
+        @errors << "Unable to detect archive format"
+        return
+      end
+
+      @warnings << "Format detected as: #{@format}"
+    end
+
+    def validate_quick
+      return unless @format
+
+      # Basic file checks
+      validate_file_exists
+      validate_file_readable
+      validate_magic_bytes
+    end
+
+    def validate_standard
+      validate_quick
+      return unless @errors.empty?
+
+      # Structure validation
+      validate_structure
+      validate_checksums if should_validate_checksums?
+    end
+
+    def validate_thorough
+      validate_standard
+      return unless @errors.empty?
+
+      # Full decompression test
+      validate_decompression
+      validate_file_integrity
+    end
+
+    def validate_file_exists
+      return if File.exist?(@path)
+
+      @errors << "File does not exist: #{@path}"
+    end
+
+    def validate_file_readable
+      return if File.readable?(@path)
+
+      @errors << "File is not readable: #{@path}"
+    end
+
+    def validate_magic_bytes
+      File.open(@path, "rb") do |f|
+        magic = f.read(4)
+
+        expected = expected_magic_bytes(@format)
+        @errors << "Invalid magic bytes for #{@format} format" unless expected.any? do |m|
+          magic.start_with?(m)
+        end
+      end
+    rescue StandardError => e
+      @errors << "Error reading magic bytes: #{e.message}"
+    end
+
+    def validate_structure
+      parser_class = FormatDetector.format_to_parser(@format)
+      unless parser_class
+        @errors << "No parser available for format: #{@format}"
+        return
+      end
+
+      archive = parser_class.new.parse(@path)
+
+      # Format-specific structure validation
+      case @format
+      when :cab
+        validate_cab_structure(archive)
+      when :chm
+        validate_chm_structure(archive)
+      end
+    rescue StandardError => e
+      @errors << "Structure validation failed: #{e.message}"
+    end
+
+    def validate_cab_structure(cabinet)
+      # Validate CAB header
+      unless cabinet.respond_to?(:header)
+        @errors << "Missing CAB header"
+        return
+      end
+
+      header = cabinet.header
+
+      # Check version
+      unless header.version_major == 1 && header.version_minor >= 1
+        @warnings << "Unusual CAB version: #{header.version_major}.#{header.version_minor}"
+      end
+
+      # Check folder count
+      @errors << "CAB has no folders" if cabinet.folders.empty?
+
+      # Check file count
+      @warnings << "CAB has no files" if cabinet.files.empty?
+
+      # Validate folder indices
+      cabinet.files.each do |file|
+        @errors << "File #{file.name} references invalid folder index" if file.folder_index >= cabinet.folders.count
+      end
+    end
+
+    def validate_chm_structure(chm)
+      return unless chm.files.empty?
+
+      @warnings << "CHM has no files"
+    end
+
+    def validate_checksums
+      case @format
+      when :cab
+        validate_cab_checksums
+      end
+    rescue StandardError => e
+      @errors << "Checksum validation failed: #{e.message}"
+    end
+
+    def validate_cab_checksums
+      parser = Cabriolet::CAB::Parser.new(skip_checksum: false)
+      begin
+        parser.parse(@path)
+        @warnings << "All checksums valid"
+      rescue Cabriolet::ChecksumError => e
+        @errors << "Checksum error: #{e.message}"
+      end
+    end
+
+    def validate_decompression
+      parser_class = FormatDetector.format_to_parser(@format)
+      archive = parser_class.new.parse(@path)
+
+      file_count = 0
+      failed_count = 0
+
+      archive.files.each do |file|
+        file_count += 1
+        begin
+          data = file.data
+          if data.nil? || (file.respond_to?(:size) && data.bytesize != file.size)
+            @warnings << "File size mismatch: #{file.name}"
+          end
+        rescue StandardError => e
+          failed_count += 1
+          @errors << "Failed to decompress #{file.name}: #{e.message}"
+        end
+      end
+
+      if failed_count.zero?
+        @warnings << "All #{file_count} files decompressed successfully"
+      else
+        @errors << "#{failed_count} out of #{file_count} files failed to decompress"
+      end
+    end
+
+    def validate_file_integrity
+      # Additional integrity checks could be added here
+      # For example: path traversal detection, suspicious file names, etc.
+
+      parser_class = FormatDetector.format_to_parser(@format)
+      archive = parser_class.new.parse(@path)
+
+      archive.files.each do |file|
+        # Check for path traversal attempts
+        @warnings << "Suspicious path detected: #{file.name}" if file.name.include?("..") || file.name.start_with?("/")
+
+        # Check for extremely long file names
+        @warnings << "Unusually long filename: #{file.name[0..50]}..." if file.name.length > 255
+      end
+    end
+
+    def should_validate_checksums?
+      @format == :cab # Only CAB format has checksums
+    end
+
+    def expected_magic_bytes(format)
+      case format
+      when :cab
+        ["MSCF"]
+      when :chm
+        ["ITSF"]
+      when :hlp
+        ["\x3F\x5F", "\x4C\x4E"]
+      when :kwaj
+        ["KWAJ"]
+      when :szdd
+        ["SZDD", "\x88\xF0\x27\x00"]
+      when :lit
+        ["ITOLITLS"]
+      else
+        []
+      end
+    end
+  end
+
+  # Validation report object
+  class ValidationReport
+    attr_reader :valid, :format, :level, :errors, :warnings, :path
+
+    def initialize(valid:, format:, level:, errors:, warnings:, path:)
+      @valid = valid
+      @format = format
+      @level = level
+      @errors = errors
+      @warnings = warnings
+      @path = path
+    end
+
+    def valid?
+      @valid
+    end
+
+    def has_errors?
+      !@errors.empty?
+    end
+
+    def has_warnings?
+      !@warnings.empty?
+    end
+
+    def summary
+      status = valid? ? "VALID" : "INVALID"
+      "#{status} - #{@format} archive (#{@level} validation)\n" \
+        "Errors: #{@errors.count}, Warnings: #{@warnings.count}"
+    end
+
+    def detailed_report
+      report = ["=" * 60]
+      report << "Validation Report"
+      report << ("=" * 60)
+      report << "File: #{@path}"
+      report << "Format: #{@format}"
+      report << "Level: #{@level}"
+      report << "Status: #{valid? ? 'VALID' : 'INVALID'}"
+      report << ""
+
+      if has_errors?
+        report << "ERRORS:"
+        @errors.each_with_index do |error, i|
+          report << "  #{i + 1}. #{error}"
+        end
+        report << ""
+      end
+
+      if has_warnings?
+        report << "WARNINGS:"
+        @warnings.each_with_index do |warning, i|
+          report << "  #{i + 1}. #{warning}"
+        end
+        report << ""
+      end
+
+      report << ("=" * 60)
+      report.join("\n")
+    end
+
+    def to_h
+      {
+        valid: @valid,
+        format: @format,
+        level: @level,
+        path: @path,
+        error_count: @errors.count,
+        warning_count: @warnings.count,
+        errors: @errors,
+        warnings: @warnings,
+      }
+    end
+
+    def to_json(*args)
+      require "json"
+      to_h.to_json(*args)
+    end
+  end
+end

data/lib/cabriolet/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  VERSION = "0.1.0"
+end

data/lib/cabriolet.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "cabriolet/version"
+require_relative "cabriolet/errors"
+require_relative "cabriolet/constants"
+
+# Cabriolet is a pure Ruby library for extracting Microsoft Cabinet (.CAB) files,
+# CHM (Compiled HTML Help) files, and related compression formats.
+module Cabriolet
+  class << self
+    # Enable or disable verbose output
+    attr_accessor :verbose
+
+    # Default buffer size for I/O operations (4KB)
+    attr_accessor :default_buffer_size
+  end
+
+  self.verbose = false
+  self.default_buffer_size = 4096
+end
+
+# Load core components
+require_relative "cabriolet/system/io_system"
+require_relative "cabriolet/system/file_handle"
+require_relative "cabriolet/system/memory_handle"
+
+require_relative "cabriolet/binary/structures"
+require_relative "cabriolet/binary/bitstream"
+require_relative "cabriolet/binary/bitstream_writer"
+require_relative "cabriolet/binary/chm_structures"
+require_relative "cabriolet/binary/szdd_structures"
+require_relative "cabriolet/binary/kwaj_structures"
+require_relative "cabriolet/binary/hlp_structures"
+require_relative "cabriolet/binary/lit_structures"
+require_relative "cabriolet/binary/oab_structures"
+
+require_relative "cabriolet/models/cabinet"
+require_relative "cabriolet/models/folder"
+require_relative "cabriolet/models/file"
+require_relative "cabriolet/models/chm_header"
+require_relative "cabriolet/models/chm_file"
+require_relative "cabriolet/models/chm_section"
+require_relative "cabriolet/models/szdd_header"
+require_relative "cabriolet/models/kwaj_header"
+require_relative "cabriolet/models/hlp_header"
+require_relative "cabriolet/models/hlp_file"
+require_relative "cabriolet/models/lit_header"
+require_relative "cabriolet/models/oab_header"
+
+require_relative "cabriolet/huffman/tree"
+require_relative "cabriolet/huffman/decoder"
+require_relative "cabriolet/huffman/encoder"
+
+require_relative "cabriolet/decompressors/base"
+require_relative "cabriolet/decompressors/none"
+require_relative "cabriolet/decompressors/lzss"
+require_relative "cabriolet/decompressors/mszip"
+require_relative "cabriolet/decompressors/lzx"
+require_relative "cabriolet/decompressors/quantum"
+
+require_relative "cabriolet/compressors/base"
+require_relative "cabriolet/compressors/lzss"
+require_relative "cabriolet/compressors/mszip"
+require_relative "cabriolet/compressors/lzx"
+require_relative "cabriolet/compressors/quantum"
+
+require_relative "cabriolet/cab/parser"
+require_relative "cabriolet/cab/decompressor"
+require_relative "cabriolet/cab/extractor"
+require_relative "cabriolet/cab/compressor"
+
+require_relative "cabriolet/chm/parser"
+require_relative "cabriolet/chm/decompressor"
+require_relative "cabriolet/chm/compressor"
+
+require_relative "cabriolet/szdd/parser"
+require_relative "cabriolet/szdd/decompressor"
+require_relative "cabriolet/szdd/compressor"
+
+require_relative "cabriolet/kwaj/parser"
+require_relative "cabriolet/kwaj/decompressor"
+require_relative "cabriolet/kwaj/compressor"
+
+require_relative "cabriolet/hlp/parser"
+require_relative "cabriolet/hlp/decompressor"
+require_relative "cabriolet/hlp/compressor"
+
+require_relative "cabriolet/lit/decompressor"
+require_relative "cabriolet/lit/compressor"
+
+require_relative "cabriolet/oab/decompressor"
+require_relative "cabriolet/oab/compressor"
+
+# Load new advanced features
+require_relative "cabriolet/format_detector"
+require_relative "cabriolet/auto"
+require_relative "cabriolet/streaming"
+require_relative "cabriolet/validator"
+require_relative "cabriolet/repairer"
+require_relative "cabriolet/modifier"
+require_relative "cabriolet/parallel"
+
+# Load CLI (optional, for command-line usage)
+require_relative "cabriolet/cli"

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: cabriolet
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose Inc.
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: |
+  Cabriolet is a pure Ruby gem for extracting Microsoft Cabinet (.CAB) files.
+  It supports multiple compression algorithms (MSZIP, LZX, Quantum, LZSS) and
+  requires no C extensions, making it portable across all Ruby platforms.
+email:
+- open.source@ribose.com
+executables:
+- cabriolet
+extensions: []
+extra_rdoc_files: []
+files:
+- ARCHITECTURE.md
+- CHANGELOG.md
+- LICENSE
+- README.adoc
+- exe/cabriolet
+- lib/cabriolet.rb
+- lib/cabriolet/auto.rb
+- lib/cabriolet/binary/bitstream.rb
+- lib/cabriolet/binary/bitstream_writer.rb
+- lib/cabriolet/binary/chm_structures.rb
+- lib/cabriolet/binary/hlp_structures.rb
+- lib/cabriolet/binary/kwaj_structures.rb
+- lib/cabriolet/binary/lit_structures.rb
+- lib/cabriolet/binary/oab_structures.rb
+- lib/cabriolet/binary/structures.rb
+- lib/cabriolet/binary/szdd_structures.rb
+- lib/cabriolet/cab/compressor.rb
+- lib/cabriolet/cab/decompressor.rb
+- lib/cabriolet/cab/extractor.rb
+- lib/cabriolet/cab/parser.rb
+- lib/cabriolet/chm/compressor.rb
+- lib/cabriolet/chm/decompressor.rb
+- lib/cabriolet/chm/parser.rb
+- lib/cabriolet/cli.rb
+- lib/cabriolet/compressors/base.rb
+- lib/cabriolet/compressors/lzss.rb
+- lib/cabriolet/compressors/lzx.rb
+- lib/cabriolet/compressors/mszip.rb
+- lib/cabriolet/compressors/quantum.rb
+- lib/cabriolet/constants.rb
+- lib/cabriolet/decompressors/base.rb
+- lib/cabriolet/decompressors/lzss.rb
+- lib/cabriolet/decompressors/lzx.rb
+- lib/cabriolet/decompressors/mszip.rb
+- lib/cabriolet/decompressors/none.rb
+- lib/cabriolet/decompressors/quantum.rb
+- lib/cabriolet/errors.rb
+- lib/cabriolet/format_detector.rb
+- lib/cabriolet/hlp/compressor.rb
+- lib/cabriolet/hlp/decompressor.rb
+- lib/cabriolet/hlp/parser.rb
+- lib/cabriolet/huffman/decoder.rb
+- lib/cabriolet/huffman/encoder.rb
+- lib/cabriolet/huffman/tree.rb
+- lib/cabriolet/kwaj/compressor.rb
+- lib/cabriolet/kwaj/decompressor.rb
+- lib/cabriolet/kwaj/parser.rb
+- lib/cabriolet/lit/compressor.rb
+- lib/cabriolet/lit/decompressor.rb
+- lib/cabriolet/models/cabinet.rb
+- lib/cabriolet/models/chm_file.rb
+- lib/cabriolet/models/chm_header.rb
+- lib/cabriolet/models/chm_section.rb
+- lib/cabriolet/models/file.rb
+- lib/cabriolet/models/folder.rb
+- lib/cabriolet/models/folder_data.rb
+- lib/cabriolet/models/hlp_file.rb
+- lib/cabriolet/models/hlp_header.rb
+- lib/cabriolet/models/kwaj_header.rb
+- lib/cabriolet/models/lit_header.rb
+- lib/cabriolet/models/oab_header.rb
+- lib/cabriolet/models/szdd_header.rb
+- lib/cabriolet/modifier.rb
+- lib/cabriolet/oab/compressor.rb
+- lib/cabriolet/oab/decompressor.rb
+- lib/cabriolet/parallel.rb
+- lib/cabriolet/repairer.rb
+- lib/cabriolet/streaming.rb
+- lib/cabriolet/system/file_handle.rb
+- lib/cabriolet/system/io_system.rb
+- lib/cabriolet/system/memory_handle.rb
+- lib/cabriolet/szdd/compressor.rb
+- lib/cabriolet/szdd/decompressor.rb
+- lib/cabriolet/szdd/parser.rb
+- lib/cabriolet/validator.rb
+- lib/cabriolet/version.rb
+homepage: https://github.com/omnizip/cabriolet
+licenses:
+- BSD-3-Clause
+metadata:
+  homepage_uri: https://github.com/omnizip/cabriolet
+  source_code_uri: https://github.com/omnizip/cabriolet
+  changelog_uri: https://github.com/omnizip/cabriolet/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/omnizip/cabriolet/issues
+  documentation_uri: https://rubydoc.info/gems/cabriolet
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Pure Ruby implementation for extracting Microsoft Cabinet files
+test_files: []