omnizip 0.4.7-aarch64-linux

data/lib/omnizip/filter.rb

@@ -0,0 +1,141 @@
+# 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
+  # Abstract base class for all preprocessing filters
+  #
+  # Filters are reversible transformations applied to data before
+  # compression to improve compression ratios. This class defines the
+  # interface that all filter implementations must follow.
+  #
+  # The key innovation is format-aware ID resolution: different formats
+  # (7z, XZ) use different IDs for the same filter. This class provides the
+  # id_for_format(format) method to handle this mapping.
+  #
+  # @abstract Subclasses must implement encode, decode, metadata
+  #
+  # @example Create a custom filter
+  #   class MyFilter < Filter
+  #     def initialize(architecture:)
+  #       super(architecture: architecture, name: "MyFilter")
+  #     end
+  #
+  #     def id_for_format(format)
+  #       format == :xz ? 0x04 : 0x03
+  #     end
+  #
+  #     def encode(data, position = 0)
+  #       # encoding logic
+  #     end
+  #
+  #     def decode(data, position = 0)
+  #       # decoding logic
+  #     end
+  #
+  #     def self.metadata
+  #       { name: "MyFilter", description: "..." }
+  #     end
+  #   end
+  class Filter
+    # @return [Symbol, nil] Architecture identifier (:x86, :arm, :arm64,
+    #   :powerpc, :ia64, :sparc) or nil for architecture-agnostic filters
+    attr_reader :architecture
+
+    # @return [String] Human-readable filter name
+    attr_reader :name
+
+    # Initialize filter
+    #
+    # @param architecture [Symbol, nil] Target architecture (optional;
+    #   filters that don't vary by architecture leave this as nil)
+    # @param name [String] Human-readable name
+    def initialize(architecture: nil, name: "Unknown")
+      @architecture = architecture
+      @name = name
+    end
+
+    # Get filter ID for specific format
+    #
+    # This is the KEY METHOD that solves the filter ID mapping problem.
+    # Different formats (7z, XZ) use different IDs for the same filter.
+    #
+    # @param format [Symbol] Format identifier (:seven_zip, :xz)
+    # @return [Integer] Format-specific filter ID
+    # @raise [NotImplementedError] Subclass must implement
+    #
+    # @example Get XZ format ID for BCJ filter
+    #   bcj.id_for_format(:xz)  # => 0x04
+    #
+    # @example Get 7z format ID for BCJ filter
+    #   bcj.id_for_format(:seven_zip)  # => 0x03030103
+    def id_for_format(format)
+      raise NotImplementedError,
+            "#{self.class} must implement #id_for_format(format)"
+    end
+
+    # Encode (preprocess) data for compression
+    #
+    # Transforms data to make it more compressible. The transformation
+    # must be reversible - decode(encode(data)) == data.
+    #
+    # @param data [String] Binary data to encode
+    # @param position [Integer] Current stream position (default: 0)
+    # @return [String] Encoded binary data
+    # @raise [NotImplementedError] Subclass must implement
+    def encode(data, position = 0)
+      raise NotImplementedError,
+            "#{self.class} must implement #encode(data, position)"
+    end
+
+    # Decode (postprocess) data after decompression
+    #
+    # Reverses the encoding transformation, restoring original data.
+    #
+    # @param data [String] Binary data to decode
+    # @param position [Integer] Current stream position (default: 0)
+    # @return [String] Decoded binary data
+    # @raise [NotImplementedError] Subclass must implement
+    def decode(data, position = 0)
+      raise NotImplementedError,
+            "#{self.class} must implement #decode(data, position)"
+    end
+
+    class << self
+      # Get metadata about this filter
+      #
+      # @return [Hash] Filter metadata
+      # @option metadata [String] :name Human-readable name
+      # @option metadata [String] :description Filter description
+      # @option metadata [Array<Symbol>] :supported_archs Supported architectures
+      # @raise [NotImplementedError] Subclass must implement
+      #
+      # @example Get BCJ filter metadata
+      #   Omnizip::Filters::BCJ.metadata
+      #   # => { name: "BCJ", description: "...", supported_archs: [:x86, :arm, ...] }
+      def metadata
+        raise NotImplementedError,
+              "#{self} must implement .metadata"
+      end
+    end
+  end
+end

data/lib/omnizip/filter_pipeline.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  # Pipeline for chaining multiple filters together.
+  #
+  # Filters are applied in sequence during encoding, and in reverse
+  # order during decoding. Position tracking is maintained across
+  # the entire pipeline.
+  class FilterPipeline
+    attr_reader :filters
+
+    # Initialize an empty filter pipeline.
+    def initialize
+      @filters = []
+      @position = 0
+    end
+
+    # Add a filter to the pipeline.
+    #
+    # Filters are applied in the order they are added during encoding,
+    # and in reverse order during decoding.
+    #
+    # @param filter [Omnizip::Filter] Filter instance to add
+    # @return [self] For method chaining
+    def add_filter(filter)
+      @filters << filter
+      self
+    end
+
+    # Check if pipeline has any filters.
+    #
+    # @return [Boolean] True if pipeline contains filters
+    def empty?
+      @filters.empty?
+    end
+
+    # Get number of filters in pipeline.
+    #
+    # @return [Integer] Number of filters
+    def size
+      @filters.size
+    end
+
+    # Encode (preprocess) data by applying all filters in order.
+    #
+    # Filters are applied sequentially with the same position value.
+    # Position represents the current stream position for address
+    # calculations.
+    #
+    # @param data [String] Binary data to encode
+    # @param position [Integer] Current stream position
+    # @return [String] Encoded binary data
+    def encode(data, position = 0)
+      return data.dup if @filters.empty?
+
+      result = data
+      @filters.each do |filter|
+        result = filter.encode(result, position)
+      end
+
+      result
+    end
+
+    # Decode (postprocess) data by applying all filters in reverse order.
+    #
+    # Filters are applied in reverse order with the same position value
+    # to undo the encoding transformation.
+    #
+    # @param data [String] Binary data to decode
+    # @param position [Integer] Current stream position
+    # @return [String] Decoded binary data
+    def decode(data, position = 0)
+      return data.dup if @filters.empty?
+
+      result = data
+      # Apply filters in reverse order
+      @filters.reverse_each do |filter|
+        result = filter.decode(result, position)
+      end
+
+      result
+    end
+
+    # Clear all filters from the pipeline.
+    #
+    # @return [void]
+    def clear
+      @filters.clear
+      @position = 0
+    end
+  end
+end

data/lib/omnizip/filter_registry.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Omnizip
+  class FilterRegistry < Omnizip::Registry
+    DEFAULT_FORMATS = %i[xz seven_zip].freeze
+
+    # Single source of truth for builtin filters. Each entry binds the
+    # filter name to its class and the formats that support it.
+    BUILTIN_FILTERS = {
+      "bcj-x86": { const: "Omnizip::Filters::BcjX86",   formats: %i[xz seven_zip] },
+      "bcj-arm": { const: "Omnizip::Filters::BcjArm",   formats: %i[xz seven_zip] },
+      "bcj-arm64": { const: "Omnizip::Filters::BcjArm64", formats: [:seven_zip] },
+      "bcj-ia64": { const: "Omnizip::Filters::BcjIa64", formats: %i[xz seven_zip] },
+      "bcj-ppc": { const: "Omnizip::Filters::BcjPpc", formats: %i[xz seven_zip] },
+      "bcj-sparc": { const: "Omnizip::Filters::BcjSparc", formats: %i[xz seven_zip] },
+      bcj: { const: "Omnizip::Filters::BCJ", formats: [:seven_zip] },
+      bcj2: { const: "Omnizip::Filters::Bcj2", formats: [:seven_zip] },
+      delta: { const: "Omnizip::Filters::Delta", formats: %i[xz seven_zip] },
+    }.freeze
+
+    class << self
+      def not_found_error_class
+        Omnizip::UnknownFilterError
+      end
+
+      def label
+        "Filter"
+      end
+
+      def register(name, filter_class, formats: DEFAULT_FORMATS)
+        raise ArgumentError, "Filter name cannot be nil" if name.nil?
+        raise ArgumentError, "Filter class cannot be nil" if filter_class.nil?
+
+        synchronize do
+          storage[normalize_key(name)] = {
+            class: filter_class,
+            formats: formats,
+          }
+        end
+        filter_class
+      end
+      alias register_with_formats register
+
+      def get(name)
+        entry = entry_for(name)
+        unless entry
+          raise not_found_error_class,
+                "#{label} not registered: #{name.inspect}. " \
+                "Available: #{available.join(', ')}"
+        end
+
+        entry[:class]
+      end
+
+      def get_for_format(name, format)
+        entry = entry_for(name)
+        raise KeyError, "Filter not found: #{name}" unless entry
+
+        unless entry[:formats].include?(format)
+          raise ArgumentError,
+                "Filter #{name} not supported for format #{format}"
+        end
+
+        entry[:class].new
+      end
+
+      def supports_format?(name, format)
+        entry = entry_for(name)
+        return false unless entry
+
+        entry[:formats]&.include?(format)
+      end
+
+      def filters_for_format(format)
+        # Ensure all lazy triggers have fired so the format filter list
+        # reflects every registered builtin.
+        lazy_triggers.keys.dup.each { |name| get(name) }
+
+        storage.select { |_, info| info[:formats]&.include?(format) }.keys
+      end
+
+      private
+
+      def entry_for(name)
+        # Reads hold the same mutex register writes under. The lazy
+        # trigger runs OUTSIDE the lock — it re-enters through
+        # register's own synchronize.
+        normalized = normalize_key(name)
+        entry = synchronize { storage[normalized] }
+        return entry if entry
+
+        trigger = synchronize { lazy_triggers[normalized] }
+        if trigger
+          trigger.call # outside the lock — it re-enters via register
+          return synchronize { storage[normalized] }
+        end
+
+        nil
+      end
+    end
+  end
+end
+
+# Lazy triggers — each trigger resolves the filter's class (firing
+# autoload) and registers it with its declared formats. Idempotent:
+# register overwrites the storage entry. Survives reset! because the
+# trigger proc is held by FilterRegistry, not the storage.
+Omnizip::FilterRegistry::BUILTIN_FILTERS.each do |name, spec|
+  Omnizip::FilterRegistry.register_lazy(name) do
+    klass = Object.const_get(spec[:const])
+    Omnizip::FilterRegistry.register(name, klass, formats: spec[:formats])
+  end
+end

data/lib/omnizip/filters/bcj.rb

@@ -0,0 +1,277 @@
+# 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 Filters
+    # Unified BCJ (Branch/Call/Jump) filter for multiple architectures
+    #
+    # This filter preprocesses executable code by converting relative
+    # addresses in branch/call instructions to absolute addresses.
+    # The transformation is reversible and improves compression ratio.
+    #
+    # Supports x86, ARM, ARM Thumb, ARM64, PowerPC, IA64, SPARC architectures.
+    # Automatically returns correct filter ID for 7z or XZ format.
+    #
+    # @example Create x86 BCJ filter
+    #   bcj = Omnizip::Filters::BCJ.new(architecture: :x86)
+    #   bcj.id_for_format(:xz)         # => 0x04
+    #   bcj.id_for_format(:seven_zip)  # => 0x03030103
+    class BCJ < ::Omnizip::Filter
+      # Architecture-specific configurations
+      CONFIG = {
+        x86: {
+          opcodes: [0xE8, 0xE9],  # CALL, JMP
+          address_size: 4,
+          instruction_size: 5,
+          xz_id: 0x04,
+          seven_zip_id: 0x03030103,
+        },
+        arm: {
+          opcodes: [0x0A, 0x0B],  # ARM BL/B conditional
+          address_size: 4,
+          instruction_size: 4,
+          xz_id: 0x07,
+          seven_zip_id: 0x03030501,
+        },
+        armthumb: {
+          opcodes: [0xE8, 0xF0, 0xF1], # ARM Thumb BL/B conditional
+          address_size: 4,
+          instruction_size: 4,
+          xz_id: 0x08,
+          seven_zip_id: 0x03030701,
+        },
+        arm64: {
+          opcodes: [0x00], # ARM64 BL
+          address_size: 4,
+          instruction_size: 4,
+          xz_id: nil, # Not yet in XZ
+          seven_zip_id: 0x03030601,
+        },
+        powerpc: {
+          opcodes: [0x48, 0x18], # PowerPC branch instructions
+          address_size: 4,
+          instruction_size: 4,
+          xz_id: 0x05,
+          seven_zip_id: 0x03030205,
+        },
+        ia64: {
+          opcodes: [0x04, 0x05, 0x06, 0x07, 0x08], # IA64 branches
+          address_size: 4,
+          instruction_size: 4,
+          xz_id: 0x06,
+          seven_zip_id: 0x03030401,
+        },
+        sparc: {
+          opcodes: [0x04, 0x06, 0x07], # SPARC call/branch
+          address_size: 4,
+          instruction_size: 4,
+          xz_id: 0x09,
+          seven_zip_id: 0x03030805,
+        },
+      }.freeze
+
+      # @return [Symbol] Architecture identifier
+      attr_reader :architecture
+
+      # Initialize BCJ filter for specific architecture
+      #
+      # @param architecture [Symbol] Target architecture (:x86, :arm, :armthumb, :arm64, :powerpc, :ia64, :sparc)
+      # @raise [ArgumentError] If architecture is not supported
+      def initialize(architecture:)
+        unless CONFIG.key?(architecture)
+          raise ArgumentError, "Unsupported BCJ architecture: #{architecture}. " \
+                               "Supported: #{CONFIG.keys.join(', ')}"
+        end
+
+        @architecture = architecture
+        @config = CONFIG[architecture]
+        super(architecture: architecture, name: "BCJ-#{architecture.to_s.upcase}")
+      end
+
+      # Get filter ID for specific format
+      #
+      # @param format [Symbol] Format identifier (:seven_zip, :xz)
+      # @return [Integer] Format-specific filter ID
+      # @raise [ArgumentError] If format is not supported
+      # @raise [NotImplementedError] If architecture not supported in format
+      def id_for_format(format)
+        case format
+        when :seven_zip
+          @config[:seven_zip_id]
+        when :xz
+          id = @config[:xz_id]
+          if id.nil?
+            raise NotImplementedError,
+                  "#{@architecture} BCJ not yet supported in XZ format"
+          end
+
+          id
+        else
+          raise ArgumentError,
+                "Unknown format: #{format}. Supported: :seven_zip, :xz"
+        end
+      end
+
+      # Encode (preprocess) data for compression
+      #
+      # Scans for branch/call opcodes and converts relative addresses
+      # to absolute addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position (default: 0)
+      # @return [String] Encoded binary data
+      def encode(data, position = 0)
+        return data.dup if data.bytesize < @config[:instruction_size]
+
+        result = data.b
+        i = 0
+        limit = data.bytesize - @config[:instruction_size]
+
+        while i <= limit
+          opcode = result.getbyte(i)
+
+          if @config[:opcodes].include?(opcode)
+            # Extract address (little-endian)
+            address = extract_address(result, i + 1)
+
+            # Check if valid relative address
+            if valid_relative_address?(address)
+              # Convert to absolute
+              absolute = address + position + i + @config[:instruction_size]
+              write_address(result, i + 1, absolute)
+            end
+
+            i += @config[:instruction_size]
+          else
+            i += 1
+          end
+        end
+
+        result
+      end
+
+      # Decode (postprocess) data after decompression
+      #
+      # Reverses encoding by converting absolute addresses back to
+      # relative addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position (default: 0)
+      # @return [String] Decoded binary data
+      def decode(data, position = 0)
+        return data.dup if data.bytesize < @config[:instruction_size]
+
+        result = data.b
+        i = 0
+        limit = data.bytesize - @config[:instruction_size]
+
+        while i <= limit
+          opcode = result.getbyte(i)
+
+          if @config[:opcodes].include?(opcode)
+            # Extract absolute address
+            absolute = extract_address(result, i + 1)
+
+            # Convert to relative
+            address = absolute - (position + i + @config[:instruction_size])
+
+            if valid_relative_address?(address)
+              write_address(result, i + 1, address)
+            end
+
+            i += @config[:instruction_size]
+          else
+            i += 1
+          end
+        end
+
+        result
+      end
+
+      class << self
+        # Get metadata about this filter
+        #
+        # @return [Hash] Filter metadata
+        def metadata
+          {
+            name: "BCJ",
+            description: "Branch/Call/Jump converter for executable files",
+            supported_architectures: CONFIG.keys,
+            architectures: {
+              x86: "x86/x86-64",
+              arm: "ARM 32-bit",
+              arm64: "ARM 64-bit",
+              powerpc: "PowerPC",
+              ia64: "IA-64 (Itanium)",
+              sparc: "SPARC",
+            },
+          }
+        end
+      end
+
+      private
+
+      # Extract address from data at offset (little-endian)
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Starting position
+      # @return [Integer] Address value
+      def extract_address(data, offset)
+        bytes = data.byteslice(offset, @config[:address_size]).bytes
+        value = bytes.each_with_index.reduce(0) do |acc, (byte, i)|
+          acc | (byte << (8 * i))
+        end
+
+        # Convert to signed if needed (for 32-bit addresses)
+        mask = (1 << (8 * @config[:address_size])) - 1
+        value.nobits?(~mask) ? value - (1 << (8 * @config[:address_size])) : value
+      end
+
+      # Write address to data at offset (little-endian)
+      #
+      # @param data [String] Binary data (modified in place)
+      # @param offset [Integer] Starting position
+      # @param value [Integer] Address value to write
+      # @return [void]
+      def write_address(data, offset, value)
+        @config[:address_size].times do |i|
+          data.setbyte(offset + i, value & 0xFF)
+          value >>= 8
+        end
+      end
+
+      # Check if address is a valid relative address
+      #
+      # Valid relative addresses have high byte of 0x00 or 0xFF,
+      # indicating small positive or negative offsets.
+      #
+      # @param value [Integer] Address value to check
+      # @return [Boolean] True if valid relative address
+      def valid_relative_address?(value)
+        unsigned = value & 0xFFFFFFFF
+        high_byte = (unsigned >> 24) & 0xFF
+        [0x00, 0xFF].include?(high_byte)
+      end
+    end
+  end
+end

data/lib/omnizip/filters/bcj2/constants.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  module Filters
+    module Bcj2Constants
+      # Number of output streams
+      NUM_STREAMS = 4
+
+      # Stream indices
+      STREAM_MAIN = 0 # Main data stream (non-convertible bytes)
+      STREAM_CALL = 1 # CALL instruction addresses (E8)
+      STREAM_JUMP = 2 # JUMP instruction addresses (E9)
+      STREAM_RC = 3   # Range coder probability stream
+
+      # x86 opcodes
+      OPCODE_CALL = 0xE8 # CALL instruction
+      OPCODE_JUMP = 0xE9 # JUMP instruction
+
+      # Size of x86 address (4 bytes, little-endian)
+      ADDRESS_SIZE = 4
+
+      # Range coder constants
+      TOP_VALUE = 1 << 24            # Range normalization threshold
+      BIT_MODEL_TOTAL_BITS = 11      # Probability model bits
+      BIT_MODEL_TOTAL = 1 << BIT_MODEL_TOTAL_BITS
+      MOVE_BITS = 5                  # Probability update shift
+
+      # Number of probability models (2 + 256)
+      # - 2 for general cases (not E8/E9, or 0F8x pattern)
+      # - 256 for byte-specific models when processing E8
+      NUM_PROBS = 2 + 256
+
+      # Initial probability value (50%)
+      INITIAL_PROB = BIT_MODEL_TOTAL >> 1
+    end
+  end
+end