cabriolet 0.1.0

data/lib/cabriolet/binary/hlp_structures.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Cabriolet
+  module Binary
+    # HLP (Windows Help) file format binary structures
+    #
+    # NOTE: This implementation is based on the knowledge that HLP files use
+    # LZSS compression with MODE_MSHELP, but cannot be fully validated due to
+    # lack of test fixtures and incomplete libmspack implementation.
+    module HLPStructures
+      # HLP file signature (common Windows Help magic)
+      # Note: Actual signature may vary; this is a placeholder
+      SIGNATURE = "?_\x03\x00".b.freeze
+
+      # HLP file header
+      #
+      # Structure (placeholder based on typical compressed formats):
+      # - 4 bytes: signature/magic
+      # - 2 bytes: version
+      # - 4 bytes: file count
+      # - 4 bytes: directory offset
+      class Header < BinData::Record
+        endian :little
+
+        string :signature, length: 4
+        uint16 :version
+        uint32 :file_count
+        uint32 :directory_offset
+      end
+
+      # HLP file entry in directory
+      #
+      # Structure:
+      # - 4 bytes: filename length
+      # - N bytes: filename (null-terminated)
+      # - 4 bytes: offset in archive
+      # - 4 bytes: uncompressed size
+      # - 4 bytes: compressed size
+      # - 1 byte: compression flag (0 = uncompressed, 1 = LZSS)
+      class FileEntry < BinData::Record
+        endian :little
+
+        uint32 :filename_length
+        string :filename, read_length: :filename_length
+        uint32 :offset
+        uint32 :uncompressed_size
+        uint32 :compressed_size
+        uint8  :compression_flag
+      end
+
+      # Topic header (for compressed help topics)
+      #
+      # Structure:
+      # - 4 bytes: uncompressed size
+      # - 4 bytes: compressed size
+      class TopicHeader < BinData::Record
+        endian :little
+
+        uint32 :uncompressed_size
+        uint32 :compressed_size
+      end
+    end
+  end
+end

data/lib/cabriolet/binary/kwaj_structures.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Cabriolet
+  module Binary
+    # KWAJ file format binary structures
+    #
+    # KWAJ has a fixed base header followed by optional headers determined
+    # by flag bits in the header.
+    module KWAJStructures
+      # KWAJ base header (14 bytes)
+      #
+      # Structure:
+      # - 4 bytes: signature1 (KWAJ)
+      # - 4 bytes: signature2 (0xD127F088)
+      # - 2 bytes: compression method
+      # - 2 bytes: data offset
+      # - 2 bytes: header flags
+      class BaseHeader < BinData::Record
+        endian :little
+
+        uint32 :signature1
+        uint32 :signature2
+        uint16 :comp_method
+        uint16 :data_offset
+        uint16 :flags
+      end
+
+      # Optional length field (4 bytes)
+      class LengthField < BinData::Record
+        endian :little
+
+        uint32 :uncompressed_length
+      end
+
+      # Optional unknown field 1 (2 bytes)
+      class Unknown1Field < BinData::Record
+        endian :little
+
+        uint16 :unknown1
+      end
+
+      # Optional unknown field 2 (variable length)
+      class Unknown2Field < BinData::Record
+        endian :little
+
+        uint16 :data_length
+        string :data, read_length: :data_length
+      end
+
+      # Optional extra text field (variable length)
+      class ExtraTextField < BinData::Record
+        endian :little
+
+        uint16 :text_length
+        string :data, read_length: :text_length
+      end
+
+      # KWAJ signature constants
+      SIGNATURE1 = 0x4A41574B # "KWAJ" in little-endian
+      SIGNATURE2 = 0xD127F088
+
+      # Helper method to check if a signature is valid
+      #
+      # @param sig1 [Integer] First signature value
+      # @param sig2 [Integer] Second signature value
+      # @return [Boolean] true if signatures are valid
+      def self.valid_signature?(sig1, sig2)
+        sig1 == SIGNATURE1 && sig2 == SIGNATURE2
+      end
+    end
+  end
+end

data/lib/cabriolet/binary/lit_structures.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Cabriolet
+  module Binary
+    # Microsoft Reader LIT file format binary structures
+    #
+    # NOTE: LIT format specifications are not publicly documented.
+    # These structures are based on analysis and reverse engineering.
+    # DES-encrypted (DRM-protected) LIT files are not supported.
+    module LITStructures
+      # LIT file signature: "ITOLITLS" or similar variants
+      # The actual signature may vary based on LIT version
+      SIGNATURE = "ITOLITLS"
+
+      # LIT file header
+      #
+      # Structure (approximate):
+      # - 8 bytes: signature
+      # - 4 bytes: version
+      # - 4 bytes: flags (includes encryption flag)
+      # - 4 bytes: file count
+      # - 4 bytes: header size
+      class LITHeader < BinData::Record
+        endian :little
+
+        string :signature, length: 8
+        uint32 :version
+        uint32 :flags
+        uint32 :file_count
+        uint32 :header_size
+      end
+
+      # LIT file entry in the directory
+      #
+      # Structure (approximate):
+      # - 4 bytes: filename length
+      # - N bytes: filename (UTF-8 or UTF-16)
+      # - 8 bytes: file offset
+      # - 8 bytes: compressed size
+      # - 8 bytes: uncompressed size
+      # - 4 bytes: flags (compressed, encrypted, etc.)
+      class LITFileEntry < BinData::Record
+        endian :little
+
+        uint32 :filename_length
+        string :filename, read_length: :filename_length
+        uint64 :offset
+        uint64 :compressed_size
+        uint64 :uncompressed_size
+        uint32 :flags
+      end
+
+      # LIT content section header
+      #
+      # Structure (approximate):
+      # - 4 bytes: section type
+      # - 4 bytes: section size
+      # - 4 bytes: compression method (0 = none, 1 = LZX)
+      # - 4 bytes: encryption method (0 = none, 1 = DES)
+      class SectionHeader < BinData::Record
+        endian :little
+
+        uint32 :section_type
+        uint32 :section_size
+        uint32 :compression_method
+        uint32 :encryption_method
+      end
+
+      # DES encryption header (if encrypted)
+      #
+      # NOTE: DES encryption is not currently supported.
+      # This structure is provided for completeness.
+      #
+      # Structure (approximate):
+      # - 16 bytes: encryption key hash
+      # - 8 bytes: IV (initialization vector)
+      # - 4 bytes: encryption flags
+      class EncryptionHeader < BinData::Record
+        endian :little
+
+        string :key_hash, length: 16
+        string :iv, length: 8
+        uint32 :flags
+      end
+
+      # Flags for file entries
+      module FileFlags
+        COMPRESSED = 0x01
+        ENCRYPTED  = 0x02
+      end
+
+      # Compression methods
+      module CompressionMethod
+        NONE = 0
+        LZX  = 1
+      end
+
+      # Encryption methods
+      module EncryptionMethod
+        NONE = 0
+        DES  = 1
+      end
+    end
+  end
+end

data/lib/cabriolet/binary/oab_structures.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Cabriolet
+  module Binary
+    # OAB (Outlook Offline Address Book) binary structures
+    #
+    # OAB files use LZX compression and come in two formats:
+    # - Full files (version 3.1)
+    # - Incremental patches (version 3.2)
+    module OABStructures
+      # OAB header for full files (version 3.1)
+      #
+      # Structure (16 bytes):
+      # - 4 bytes: version_hi (should be 3)
+      # - 4 bytes: version_lo (should be 1 for full files)
+      # - 4 bytes: block_max (maximum block size)
+      # - 4 bytes: target_size (decompressed output size)
+      class FullHeader < BinData::Record
+        endian :little
+
+        uint32 :version_hi
+        uint32 :version_lo
+        uint32 :block_max
+        uint32 :target_size
+
+        # Check if header is valid
+        #
+        # @return [Boolean]
+        def valid?
+          version_hi == 3 && version_lo == 1
+        end
+      end
+
+      # OAB block header for full files
+      #
+      # Structure (16 bytes):
+      # - 4 bytes: flags (0=uncompressed, 1=LZX compressed)
+      # - 4 bytes: compressed_size
+      # - 4 bytes: uncompressed_size
+      # - 4 bytes: crc (CRC32 of decompressed data)
+      class BlockHeader < BinData::Record
+        endian :little
+
+        uint32 :flags
+        uint32 :compressed_size
+        uint32 :uncompressed_size
+        uint32 :crc
+
+        # Check if block is compressed
+        #
+        # @return [Boolean]
+        def compressed?
+          flags == 1
+        end
+
+        # Check if block is uncompressed
+        #
+        # @return [Boolean]
+        def uncompressed?
+          flags.zero?
+        end
+      end
+
+      # OAB header for patch files (version 3.2)
+      #
+      # Structure (28 bytes):
+      # - 4 bytes: version_hi (should be 3)
+      # - 4 bytes: version_lo (should be 2 for patches)
+      # - 4 bytes: block_max (maximum block size)
+      # - 4 bytes: source_size (base file size)
+      # - 4 bytes: target_size (output file size)
+      # - 4 bytes: source_crc (CRC32 of base file)
+      # - 4 bytes: target_crc (CRC32 of output file)
+      class PatchHeader < BinData::Record
+        endian :little
+
+        uint32 :version_hi
+        uint32 :version_lo
+        uint32 :block_max
+        uint32 :source_size
+        uint32 :target_size
+        uint32 :source_crc
+        uint32 :target_crc
+
+        # Check if header is valid
+        #
+        # @return [Boolean]
+        def valid?
+          version_hi == 3 && version_lo == 2
+        end
+      end
+
+      # OAB block header for patch files
+      #
+      # Structure (16 bytes):
+      # - 4 bytes: patch_size (compressed patch data size)
+      # - 4 bytes: target_size (decompressed output block size)
+      # - 4 bytes: source_size (base data needed for this block)
+      # - 4 bytes: crc (CRC32 of decompressed output)
+      class PatchBlockHeader < BinData::Record
+        endian :little
+
+        uint32 :patch_size
+        uint32 :target_size
+        uint32 :source_size
+        uint32 :crc
+      end
+    end
+  end
+end

data/lib/cabriolet/binary/structures.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Cabriolet
+  module Binary
+    # CAB file header structure (CFHEADER)
+    class CFHeader < BinData::Record
+      endian :little
+
+      string :signature, length: 4
+      uint32 :reserved1
+      uint32 :cabinet_size
+      uint32 :reserved2
+      uint32 :files_offset
+      uint32 :reserved3
+      uint8  :minor_version
+      uint8  :major_version
+      uint16 :num_folders
+      uint16 :num_files
+      uint16 :flags
+      uint16 :set_id
+      uint16 :cabinet_index
+    end
+
+    # Folder structure (CFFOLDER)
+    class CFFolder < BinData::Record
+      endian :little
+
+      uint32 :data_offset
+      uint16 :num_blocks
+      uint16 :comp_type
+    end
+
+    # File structure (CFFILE)
+    class CFFile < BinData::Record
+      endian :little
+
+      uint32 :uncompressed_size
+      uint32 :folder_offset
+      uint16 :folder_index
+      uint16 :date
+      uint16 :time
+      uint16 :attribs
+    end
+
+    # Data block structure (CFDATA)
+    class CFData < BinData::Record
+      endian :little
+
+      uint32 :checksum
+      uint16 :compressed_size
+      uint16 :uncompressed_size
+    end
+  end
+end

data/lib/cabriolet/binary/szdd_structures.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Cabriolet
+  module Binary
+    # SZDD file format binary structures
+    module SZDDStructures
+      # SZDD signatures
+      SIGNATURE_NORMAL = [0x53, 0x5A, 0x44, 0x44, 0x88, 0xF0, 0x27, 0x33]
+        .pack("C*").freeze
+      SIGNATURE_QBASIC = [0x53, 0x5A, 0x20, 0x88, 0xF0, 0x27, 0x33, 0xD1]
+        .pack("C*").freeze
+
+      # SZDD header for NORMAL format (EXPAND.EXE)
+      #
+      # Structure:
+      # - 8 bytes: signature (SZDD\x88\xF0\x27\x33)
+      # - 1 byte: compression mode (0x41)
+      # - 1 byte: missing character
+      # - 4 bytes: uncompressed size (little-endian)
+      class NormalHeader < BinData::Record
+        endian :little
+
+        string :signature, length: 8
+        uint8  :compression_mode
+        uint8  :missing_char
+        uint32 :uncompressed_size
+      end
+
+      # SZDD header for QBASIC format
+      #
+      # Structure:
+      # - 8 bytes: signature (SZDD \x88\xF0\x27\x33\xD1)
+      # - 4 bytes: uncompressed size (little-endian)
+      class QBasicHeader < BinData::Record
+        endian :little
+
+        string :signature, length: 8
+        uint32 :uncompressed_size
+      end
+
+      # Header data for NORMAL format (after signature)
+      class NormalData < BinData::Record
+        endian :little
+
+        uint8  :compression_mode
+        uint8  :missing_char
+        uint32 :uncompressed_size
+      end
+
+      # Header data for QBASIC format (after signature)
+      class QBasicData < BinData::Record
+        endian :little
+
+        uint32 :uncompressed_size
+      end
+    end
+  end
+end