omnizip 0.4.7-x86_64-linux

data/lib/omnizip/formats/seven_zip.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    # .7z archive format support
+    # Provides read and write access to 7-Zip archives
+    #
+    # This module implements the .7z archive format specification,
+    # supporting:
+    # - Format signature and header validation
+    # - Archive structure parsing
+    # - File extraction
+    # - Archive creation
+    # - Split archives (multi-volume)
+    module SevenZip
+      # Nested classes - autoloaded
+      autoload :Constants, "omnizip/formats/seven_zip/constants"
+      autoload :Header, "omnizip/formats/seven_zip/header"
+      autoload :Parser, "omnizip/formats/seven_zip/parser"
+      autoload :Reader, "omnizip/formats/seven_zip/reader"
+      autoload :Writer, "omnizip/formats/seven_zip/writer"
+      autoload :CoderChain, "omnizip/formats/seven_zip/coder_chain"
+      autoload :StreamDecompressor,
+               "omnizip/formats/seven_zip/stream_decompressor"
+      autoload :StreamCompressor, "omnizip/formats/seven_zip/stream_compressor"
+      autoload :FileCollector, "omnizip/formats/seven_zip/file_collector"
+      autoload :HeaderWriter, "omnizip/formats/seven_zip/header_writer"
+      autoload :SplitArchiveReader,
+               "omnizip/formats/seven_zip/split_archive_reader"
+      autoload :SplitArchiveWriter,
+               "omnizip/formats/seven_zip/split_archive_writer"
+      autoload :HeaderEncryptor, "omnizip/formats/seven_zip/header_encryptor"
+      autoload :EncryptedHeader, "omnizip/formats/seven_zip/encrypted_header"
+      autoload :EncodedHeader, "omnizip/formats/seven_zip/encoded_header"
+      autoload :Bcj2StreamDecompressor,
+               "omnizip/formats/seven_zip/bcj2_stream_decompressor"
+      module Models
+        autoload :StreamInfo, "omnizip/formats/seven_zip/models/stream_info"
+        autoload :FileEntry, "omnizip/formats/seven_zip/models/file_entry"
+        autoload :Folder, "omnizip/formats/seven_zip/models/folder"
+        autoload :CoderInfo, "omnizip/formats/seven_zip/models/coder_info"
+      end
+      # Add autoload for Models namespace itself
+      autoload :Models, "omnizip/formats/seven_zip/models"
+
+      # Cross-namespace dependencies - autoloaded
+      autoload :Crc32, "omnizip/checksums/crc32"
+      autoload :LZMA2, "omnizip/algorithms/lzma2"
+      autoload :AlgorithmRegistry, "omnizip/algorithm_registry"
+      autoload :FilterRegistry, "omnizip/filter_registry"
+      autoload :FilterPipeline, "omnizip/filter_pipeline"
+      autoload :Bcj2Decoder, "omnizip/filters/bcj2/decoder"
+      autoload :Bcj2StreamData, "omnizip/filters/bcj2/stream_data"
+
+      # Create a new .7z archive
+      #
+      # @param path [String] Output path
+      # @param options [Hash] Compression options
+      # @option options [Integer] :volume_size Volume size for split archives
+      # @option options [String] :password Password for header encryption
+      # @option options [Boolean] :encrypt_headers Encrypt archive headers
+      # @yield [writer] Block for adding files
+      # @yieldparam writer [Writer] Archive writer
+      def self.create(path, options = {})
+        writer = Writer.new(path, options)
+        yield writer if block_given?
+        writer.write
+        writer
+      end
+
+      # Create a split .7z archive
+      #
+      # @param path [String] Base path (e.g., "backup.7z.001")
+      # @param split_options [Models::SplitOptions] Split configuration
+      # @param options [Hash] Compression options
+      # @yield [writer] Block for adding files
+      # @yieldparam writer [SplitArchiveWriter] Archive writer
+      def self.create_split(path, split_options, options = {})
+        writer = SplitArchiveWriter.new(path, options, split_options)
+        yield writer if block_given?
+        writer.write
+        writer
+      end
+
+      # Open existing .7z archive
+      #
+      # @param path [String] Archive path
+      # @param options [Hash] Reader options
+      # @option options [String] :password Password for encrypted headers
+      # @yield [reader] Block for reading archive
+      # @yieldparam reader [Reader] Archive reader
+      # @return [Reader] Archive reader
+      def self.open(path, options = {})
+        reader = Reader.new(path, options)
+        reader.open
+
+        if block_given?
+          begin
+            yield reader
+          ensure
+            reader.split_reader&.close
+          end
+        end
+
+        reader
+      end
+
+      # Search for embedded .7z archive in self-extracting executable
+      #
+      # Scans the file for 7z signatures and validates each candidate by
+      # checking the Start Header (version bytes, CRC, and header field
+      # sanity). Returns the offset of the first valid embedded archive.
+      #
+      # @param path [String] Path to potential self-extracting archive
+      # @return [Integer, nil] Offset of embedded 7z signature, or nil if not found
+      def self.search_embedded(path)
+        data = File.binread(path)
+        file_size = data.bytesize
+        signature = Constants::SIGNATURE
+        pos = 0
+
+        while (offset = data.index(signature, pos))
+          if valid_7z_start_header?(data, offset, file_size)
+            return offset
+          end
+
+          pos = offset + 1
+        end
+
+        nil
+      end
+
+      # Validate a candidate 7z Start Header at the given offset.
+      #
+      # Checks:
+      # 1. Enough bytes remain for a full 32-byte Start Header
+      # 2. Major version is 0 and minor version is 4 (only supported version)
+      # 3. Next Header offset + size points within (or at the end of) the file
+      # 4. Start Header CRC matches the header content
+      #
+      # @param data [String] File data
+      # @param offset [Integer] Offset of the 7z signature
+      # @param file_size [Integer] Total file size
+      # @return [Boolean] true if the header looks valid
+      def self.valid_7z_start_header?(data, offset, file_size)
+        header_size = Constants::START_HEADER_SIZE # 32
+        return false if offset + header_size > file_size
+
+        header_data = data.byteslice(offset, header_size)
+
+        # Check version byte (offset 6) - only major version is validated per 7-Zip SDK
+        # See: https://github.com/ip7z/7zip/blob/main/CPP/7zip/Archive/7z/7zIn.cpp#L1591-L1598
+        major_version = header_data.getbyte(6)
+        return false unless major_version == Constants::MAJOR_VERSION
+
+        # Parse Start Header fields (bytes 12-31)
+        next_header_data = header_data.byteslice(12, 20)
+        next_header_offset = next_header_data.unpack1("Q<")
+        next_header_size = next_header_data.byteslice(8, 8).unpack1("Q<")
+
+        # next_header_offset is relative to end of Start Header
+        header_end = offset + header_size + next_header_offset + next_header_size
+        return false if header_end > file_size
+        return false if next_header_size.zero? || next_header_size > file_size
+
+        # Validate Start Header CRC (bytes 8-11) over next_header_data (bytes 12-31)
+        stored_crc = header_data.byteslice(8, 4).unpack1("V")
+        computed_crc = Omnizip::Checksums::Crc32.new.tap do |c|
+          c.update(next_header_data)
+        end.finalize
+        return false unless stored_crc == computed_crc
+
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/omnizip/formats/tar/constants.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Tar
+      # TAR format constants
+      module Constants
+        # TAR header size (POSIX ustar format)
+        HEADER_SIZE = 512
+
+        # Block size for TAR archives
+        BLOCK_SIZE = 512
+
+        # Type flags for TAR entries
+        TYPE_REGULAR = "0"        # Regular file
+        TYPE_HARD_LINK = "1"      # Hard link
+        TYPE_SYMLINK = "2"        # Symbolic link
+        TYPE_CHAR_DEVICE = "3"    # Character device
+        TYPE_BLOCK_DEVICE = "4"   # Block device
+        TYPE_DIRECTORY = "5"      # Directory
+        TYPE_FIFO = "6"           # FIFO
+        TYPE_CONTIGUOUS = "7"     # Contiguous file
+        TYPE_EXTENDED = "x"       # Extended header
+        TYPE_GLOBAL_EXTENDED = "g" # Global extended header
+        TYPE_GNU_LONGNAME = "L"   # GNU long name
+        TYPE_GNU_LONGLINK = "K"   # GNU long link
+
+        # POSIX ustar magic value
+        USTAR_MAGIC = "ustar"
+
+        # POSIX ustar version
+        USTAR_VERSION = "00"
+
+        # Maximum file size (8GB - 1 for base-8 12-byte field)
+        MAX_FILE_SIZE = (8**12) - 1
+
+        # Field positions in TAR header
+        NAME_OFFSET = 0
+        NAME_SIZE = 100
+        MODE_OFFSET = 100
+        MODE_SIZE = 8
+        UID_OFFSET = 108
+        UID_SIZE = 8
+        GID_OFFSET = 116
+        GID_SIZE = 8
+        SIZE_OFFSET = 124
+        SIZE_SIZE = 12
+        MTIME_OFFSET = 136
+        MTIME_SIZE = 12
+        CHECKSUM_OFFSET = 148
+        CHECKSUM_SIZE = 8
+        TYPEFLAG_OFFSET = 156
+        TYPEFLAG_SIZE = 1
+        LINKNAME_OFFSET = 157
+        LINKNAME_SIZE = 100
+        MAGIC_OFFSET = 257
+        MAGIC_SIZE = 6
+        VERSION_OFFSET = 263
+        VERSION_SIZE = 2
+        UNAME_OFFSET = 265
+        UNAME_SIZE = 32
+        GNAME_OFFSET = 297
+        GNAME_SIZE = 32
+        DEVMAJOR_OFFSET = 329
+        DEVMAJOR_SIZE = 8
+        DEVMINOR_OFFSET = 337
+        DEVMINOR_SIZE = 8
+        PREFIX_OFFSET = 345
+        PREFIX_SIZE = 155
+      end
+    end
+  end
+end

data/lib/omnizip/formats/tar/entry.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Tar
+      # TAR entry model
+      #
+      # Represents a single entry (file, directory, link) in a TAR archive
+      class Entry
+        include Omnizip::Entry
+        include Omnizip::Formats::Tar::Constants
+
+        attr_accessor :name, :mode, :uid, :gid, :size, :mtime, :typeflag,
+                      :linkname, :uname, :gname, :devmajor, :devminor, :prefix
+        attr_reader :data
+
+        def entry_name = name
+        def entry_directory? = directory?
+        def entry_size = size
+        def entry_mtime = mtime
+
+        # Initialize a new TAR entry
+        #
+        # @param name [String] Entry name/path
+        # @param options [Hash] Entry options
+        def initialize(name, options = {})
+          @name = name
+          @mode = options[:mode] || 0o644
+          @uid = options[:uid] || 0
+          @gid = options[:gid] || 0
+          @size = options[:size] || 0
+          @mtime = options[:mtime] || Time.now
+          @typeflag = options[:typeflag] || TYPE_REGULAR
+          @linkname = options[:linkname] || ""
+          @uname = options[:uname] || ""
+          @gname = options[:gname] || ""
+          @devmajor = options[:devmajor] || 0
+          @devminor = options[:devminor] || 0
+          @prefix = options[:prefix] || ""
+          @data = nil
+        end
+
+        # Set entry data
+        #
+        # @param data [String] Entry data
+        def data=(data)
+          @data = data
+          @size = data.bytesize if data
+        end
+
+        # Check if entry is a directory
+        #
+        # @return [Boolean] true if directory
+        def directory?
+          @typeflag == TYPE_DIRECTORY
+        end
+
+        # Check if entry is a file
+        #
+        # @return [Boolean] true if regular file
+        def file?
+          @typeflag == TYPE_REGULAR || @typeflag.nil? || @typeflag.empty?
+        end
+
+        # Check if entry is a symbolic link
+        #
+        # @return [Boolean] true if symbolic link
+        def symlink?
+          @typeflag == TYPE_SYMLINK
+        end
+
+        # Get full entry name (prefix + name)
+        #
+        # @return [String] Full entry name
+        def full_name
+          if @prefix && !@prefix.empty?
+            File.join(@prefix, @name)
+          else
+            @name
+          end
+        end
+
+        # Calculate checksum for TAR header
+        #
+        # @param header [String] TAR header bytes
+        # @return [Integer] Checksum value
+        def self.calculate_checksum(header)
+          # Replace checksum field with spaces for calculation
+          checksum_header = header.dup
+          checksum_header[CHECKSUM_OFFSET, CHECKSUM_SIZE] = " " * CHECKSUM_SIZE
+
+          # Sum all bytes
+          checksum_header.bytes.sum
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/tar/header.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Tar
+      # TAR header parser (POSIX ustar format)
+      #
+      # Handles reading and writing 512-byte TAR headers
+      class Header
+        include Omnizip::Formats::Tar::Constants
+
+        # Parse a TAR header from binary data
+        #
+        # @param header_data [String] 512 bytes of header data
+        # @return [Entry, nil] Parsed entry or nil if end of archive
+        def self.parse(header_data)
+          return nil if header_data.nil? || header_data.bytesize < HEADER_SIZE
+          return nil if all_zeros?(header_data)
+
+          entry = Entry.new("")
+
+          # Extract fields from header
+          entry.name = extract_string(header_data, NAME_OFFSET, NAME_SIZE)
+          entry.mode = extract_octal(header_data, MODE_OFFSET, MODE_SIZE)
+          entry.uid = extract_octal(header_data, UID_OFFSET, UID_SIZE)
+          entry.gid = extract_octal(header_data, GID_OFFSET, GID_SIZE)
+          entry.size = extract_octal(header_data, SIZE_OFFSET, SIZE_SIZE)
+          entry.mtime = Time.at(
+            extract_octal(header_data, MTIME_OFFSET, MTIME_SIZE),
+          )
+          entry.typeflag = header_data[TYPEFLAG_OFFSET]
+          entry.linkname = extract_string(
+            header_data, LINKNAME_OFFSET, LINKNAME_SIZE
+          )
+
+          # Check for ustar format
+          magic = extract_string(header_data, MAGIC_OFFSET, MAGIC_SIZE)
+          if magic == USTAR_MAGIC
+            entry.uname = extract_string(header_data, UNAME_OFFSET, UNAME_SIZE)
+            entry.gname = extract_string(header_data, GNAME_OFFSET, GNAME_SIZE)
+            entry.devmajor = extract_octal(
+              header_data, DEVMAJOR_OFFSET, DEVMAJOR_SIZE
+            )
+            entry.devminor = extract_octal(
+              header_data, DEVMINOR_OFFSET, DEVMINOR_SIZE
+            )
+            entry.prefix = extract_string(
+              header_data, PREFIX_OFFSET, PREFIX_SIZE
+            )
+            # ustar stores long paths split across prefix + name;
+            # consumers see the joined path
+            unless entry.prefix.empty?
+              entry.name = "#{entry.prefix}/#{entry.name}"
+            end
+          end
+
+          # Verify checksum
+          checksum = extract_octal(
+            header_data, CHECKSUM_OFFSET, CHECKSUM_SIZE
+          )
+          calculated = Entry.calculate_checksum(header_data)
+          unless checksum == calculated
+            raise Error, "TAR header checksum mismatch"
+          end
+
+          entry
+        end
+
+        # Build a TAR header from an entry
+        #
+        # @param entry [Entry] Entry to build header for
+        # @return [String] 512 bytes of header data
+        def self.build(entry)
+          header = "\0" * HEADER_SIZE
+
+          # Write fields to header
+          name, prefix = split_long_name(entry.name, entry.prefix)
+          write_string(header, name, NAME_OFFSET, NAME_SIZE)
+          write_octal(header, entry.mode, MODE_OFFSET, MODE_SIZE)
+          write_octal(header, entry.uid, UID_OFFSET, UID_SIZE)
+          write_octal(header, entry.gid, GID_OFFSET, GID_SIZE)
+          write_octal(header, entry.size, SIZE_OFFSET, SIZE_SIZE)
+          write_octal(
+            header, entry.mtime.to_i, MTIME_OFFSET, MTIME_SIZE
+          )
+          header[TYPEFLAG_OFFSET] = entry.typeflag || TYPE_REGULAR
+          write_string(header, entry.linkname, LINKNAME_OFFSET, LINKNAME_SIZE)
+
+          # Write ustar magic and version
+          write_string(header, USTAR_MAGIC, MAGIC_OFFSET, MAGIC_SIZE)
+          write_string(header, USTAR_VERSION, VERSION_OFFSET, VERSION_SIZE)
+          write_string(header, entry.uname, UNAME_OFFSET, UNAME_SIZE)
+          write_string(header, entry.gname, GNAME_OFFSET, GNAME_SIZE)
+          write_octal(header, entry.devmajor, DEVMAJOR_OFFSET, DEVMAJOR_SIZE)
+          write_octal(header, entry.devminor, DEVMINOR_OFFSET, DEVMINOR_SIZE)
+          write_string(header, prefix, PREFIX_OFFSET, PREFIX_SIZE)
+
+          # Calculate and write checksum
+          checksum = Entry.calculate_checksum(header)
+          write_octal(header, checksum, CHECKSUM_OFFSET, CHECKSUM_SIZE)
+
+          header
+        end
+
+        # Check if header data is all zeros (end of archive marker)
+        #
+        # @param data [String] Header data
+        # @return [Boolean] true if all zeros
+        def self.all_zeros?(data)
+          data.bytes.all?(&:zero?)
+        end
+
+        # Extract a null-terminated string from header
+        #
+        # @param header [String] Header data
+        # @param offset [Integer] Field offset
+        # @param size [Integer] Field size
+        # @return [String] Extracted string
+        def self.extract_string(header, offset, size)
+          field = header[offset, size]
+          return "" if field.nil?
+
+          # Find null terminator
+          null_pos = field.index("\0")
+          null_pos ? field[0...null_pos] : field
+        end
+
+        # Extract an octal number from header
+        #
+        # @param header [String] Header data
+        # @param offset [Integer] Field offset
+        # @param size [Integer] Field size
+        # @return [Integer] Extracted number
+        def self.extract_octal(header, offset, size)
+          field = extract_string(header, offset, size)
+          field.strip.to_i(8)
+        end
+
+        # Split a path for the ustar name (100) + prefix (155)
+        # fields. Paths under 100 bytes pass through; longer paths
+        # split at a "/" boundary, preferring the longest prefix
+        # that keeps both halves in bounds. Raises when no ustar
+        # representation exists — silent truncation corrupts
+        # archives.
+        #
+        # @param path [String] Full entry path
+        # @param prefix [String] Explicit prefix (wins when given)
+        # @return [Array<String>] [name, prefix] pair
+        def self.split_long_name(path, prefix = nil)
+          path = path.to_s
+          prefix = prefix.to_s
+          return [path, prefix] if !prefix.empty? || path.bytesize < NAME_SIZE
+
+          best = nil
+          offset = -1
+          while (slash = path.index("/", offset + 1))
+            candidate_prefix = path[0...slash]
+            candidate_name = path[(slash + 1)..]
+            offset = slash
+
+            next if candidate_prefix.bytesize >= PREFIX_SIZE
+            next if candidate_name.bytesize >= NAME_SIZE
+
+            best = [candidate_name, candidate_prefix]
+          end
+
+          return best if best
+
+          raise Omnizip::FormatError,
+                "Path too long for the ustar name+prefix fields " \
+                "(no PAX/GNU long-name support): #{path}"
+        end
+
+        # Write a string to header
+        #
+        # @param header [String] Header data
+        # @param value [String] Value to write
+        # @param offset [Integer] Field offset
+        # @param size [Integer] Field size
+        def self.write_string(header, value, offset, size)
+          value = value.to_s
+          # Truncate if too long
+          value = value[0, size - 1] if value.bytesize >= size
+          header[offset, value.bytesize] = value
+        end
+
+        # Write an octal number to header
+        #
+        # @param header [String] Header data
+        # @param value [Integer] Value to write
+        # @param offset [Integer] Field offset
+        # @param size [Integer] Field size
+        def self.write_octal(header, value, offset, size)
+          # Format as octal with leading zeros
+          octal_str = format("%0#{size - 1}o", value.to_i)
+          # Truncate if too long
+          octal_str = octal_str[(-size + 1)..] if octal_str.bytesize >= size
+          header[offset, octal_str.bytesize] = octal_str
+        end
+
+        private_class_method :extract_string, :extract_octal
+        private_class_method :write_string, :write_octal, :all_zeros?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Omnizip
+  module Formats
+    module Tar
+      # TAR archive reader
+      #
+      # Reads and extracts TAR archives
+      class Reader
+        include Omnizip::Formats::Tar::Constants
+
+        attr_reader :file_path, :entries
+
+        # Initialize TAR reader
+        #
+        # @param file_path [String] Path to TAR archive
+        def initialize(file_path)
+          @file_path = file_path
+          @entries = []
+          @file = nil
+        end
+
+        # Read TAR archive and parse all entries
+        #
+        # @return [self] Returns self for method chaining
+        def read
+          File.open(@file_path, "rb") do |file|
+            @file = file
+            parse_entries
+          end
+          self
+        end
+
+        # Extract all entries to a directory
+        #
+        # @param output_dir [String] Output directory path
+        def extract_all(output_dir)
+          read unless @entries.any?
+
+          FileUtils.mkdir_p(output_dir)
+
+          @entries.each do |entry|
+            extract_entry(entry, output_dir)
+          end
+        end
+
+        # Extract a specific entry
+        #
+        # @param entry [Entry] Entry to extract
+        # @param output_dir [String] Output directory
+        def extract_entry(entry, output_dir)
+          full_path = File.join(output_dir, entry.full_name)
+
+          if entry.directory?
+            FileUtils.mkdir_p(full_path)
+          elsif entry.file?
+            FileUtils.mkdir_p(File.dirname(full_path))
+            File.binwrite(full_path, entry.data)
+            File.chmod(entry.mode, full_path) if entry.mode
+            File.utime(entry.mtime, entry.mtime, full_path) if entry.mtime
+          elsif entry.symlink?
+            FileUtils.mkdir_p(File.dirname(full_path))
+            File.symlink(entry.linkname, full_path)
+          end
+        end
+
+        # List all entries
+        #
+        # @return [Array<Entry>] List of entries
+        def list_entries
+          read unless @entries.any?
+          @entries
+        end
+
+        # Open TAR archive and yield reader
+        #
+        # @param file_path [String] Path to TAR archive
+        # @yield [Reader] Reader instance
+        def self.open(file_path)
+          reader = new(file_path)
+          reader.read
+          yield reader if block_given?
+          reader
+        end
+
+        private
+
+        # Parse all entries from TAR archive
+        def parse_entries
+          @entries = []
+
+          loop do
+            header_data = @file.read(HEADER_SIZE)
+            break if header_data.nil? || header_data.bytesize < HEADER_SIZE
+
+            entry = Header.parse(header_data)
+            break if entry.nil?
+
+            # Read entry data
+            if entry.size.positive?
+              entry.data = @file.read(entry.size)
+
+              # Skip to next block boundary
+              remainder = entry.size % BLOCK_SIZE
+              if remainder.positive?
+                padding = BLOCK_SIZE - remainder
+                @file.read(padding)
+              end
+            end
+
+            @entries << entry
+          end
+        end
+      end
+    end
+  end
+end