omnizip 0.4.7-aarch64-linux

data/lib/omnizip/filters/bcj_sparc.rb

@@ -0,0 +1,174 @@
+# 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
+    # BCJ filter for SPARC executables.
+    #
+    # This filter preprocesses SPARC machine code by converting relative
+    # addresses in CALL and BA (Branch Always) instructions to absolute
+    # addresses. SPARC uses 4-byte aligned instructions with big-endian
+    # encoding.
+    #
+    # The filter improves compression by making branch targets
+    # position-independent.
+    class BcjSparc < Omnizip::Filter
+      # Size of SPARC instruction (4 bytes, big-endian)
+      INSTRUCTION_SIZE = 4
+
+      # Flag constant for address validation
+      FLAG = 1 << 22
+
+      # Mask for offset extraction
+      OFFSET_MASK = (FLAG << 3) - 1
+
+      # Encode (preprocess) SPARC executable data for compression.
+      #
+      # Scans for CALL and BA instructions and converts relative addresses
+      # to absolute addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position
+      # @return [String] Encoded binary data
+      def encode(data, position = 0)
+        return data.dup if data.bytesize < INSTRUCTION_SIZE
+
+        result = data.b
+        size = data.bytesize & ~(INSTRUCTION_SIZE - 1)
+        i = 0
+        pc = position - INSTRUCTION_SIZE
+
+        while i < size
+          instruction = extract_uint32_be(result, i)
+          pc += INSTRUCTION_SIZE
+
+          # Check for CALL or BA instruction
+          # The check is based on specific bit patterns in SPARC ISA
+          test_val = instruction + (5 << 29)
+          test_val ^= 7 << 29
+          test_val += FLAG
+
+          if test_val.nobits?(0 - (FLAG << 1))
+            # Extract 22-bit offset (bits 0-21) or 30-bit for CALL
+            offset = (instruction << 2) & OFFSET_MASK
+
+            # Convert to absolute address
+            absolute = offset + pc
+
+            # Encode back
+            new_instruction = (absolute & OFFSET_MASK) >> 2
+            new_instruction |= 1 << 30
+            write_uint32_be(result, i, new_instruction)
+          end
+
+          i += INSTRUCTION_SIZE
+        end
+
+        result
+      end
+
+      # Decode (postprocess) SPARC executable data after decompression.
+      #
+      # Reverses the encoding by converting absolute addresses back to
+      # relative addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position
+      # @return [String] Decoded binary data
+      def decode(data, position = 0)
+        return data.dup if data.bytesize < INSTRUCTION_SIZE
+
+        result = data.b
+        size = data.bytesize & ~(INSTRUCTION_SIZE - 1)
+        i = 0
+        pc = position - INSTRUCTION_SIZE
+
+        while i < size
+          instruction = extract_uint32_be(result, i)
+          pc += INSTRUCTION_SIZE
+
+          # Check for processed instruction pattern
+          test_val = instruction + (5 << 29)
+          test_val ^= 7 << 29
+          test_val += FLAG
+
+          if test_val.nobits?(0 - (FLAG << 1))
+            # Extract absolute address
+            absolute = (instruction << 2) & OFFSET_MASK
+
+            # Convert to relative offset
+            offset = absolute - pc
+
+            # Encode back
+            new_instruction = (offset & OFFSET_MASK) >> 2
+            new_instruction |= 1 << 30
+            write_uint32_be(result, i, new_instruction)
+          end
+
+          i += INSTRUCTION_SIZE
+        end
+
+        result
+      end
+
+      class << self
+        # Get metadata about this filter.
+        #
+        # @return [Hash] Filter metadata
+        def metadata
+          {
+            name: "BCJ-SPARC",
+            description: "Branch converter for SPARC executables",
+            architecture: "SPARC",
+            alignment: 4,
+            endian: "big",
+          }
+        end
+      end
+
+      private
+
+      # Extract an unsigned 32-bit big-endian integer from data.
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Starting position
+      # @return [Integer] Unsigned 32-bit integer
+      def extract_uint32_be(data, offset)
+        bytes = data.byteslice(offset, INSTRUCTION_SIZE).bytes
+        (bytes[0] << 24) |
+          (bytes[1] << 16) |
+          (bytes[2] << 8) |
+          bytes[3]
+      end
+
+      # Write an unsigned 32-bit big-endian integer to data.
+      #
+      # @param data [String] Binary data (modified in place)
+      # @param offset [Integer] Starting position
+      # @param value [Integer] 32-bit integer to write
+      # @return [void]
+      def write_uint32_be(data, offset, value)
+        value &= 0xFFFFFFFF
+        data.setbyte(offset, (value >> 24) & 0xFF)
+        data.setbyte(offset + 1, (value >> 16) & 0xFF)
+        data.setbyte(offset + 2, (value >> 8) & 0xFF)
+        data.setbyte(offset + 3, value & 0xFF)
+      end
+    end
+  end
+end

data/lib/omnizip/filters/bcj_x86.rb

@@ -0,0 +1,191 @@
+# 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
+    # BCJ (Branch/Call/Jump) filter for x86/x64 executables.
+    #
+    # This filter preprocesses x86 machine code by converting relative
+    # addresses in CALL (0xE8) and JMP (0xE9) instructions to absolute
+    # addresses. This transformation makes the code more compressible
+    # because the addresses become position-independent.
+    #
+    # The filter is reversible and works on 5-byte boundaries (1-byte
+    # opcode + 4-byte address).
+    class BcjX86 < Omnizip::Filter
+      # x86 CALL opcode
+      OPCODE_CALL = 0xE8
+
+      # x86 JMP opcode
+      OPCODE_JMP = 0xE9
+
+      # Size of x86 address (4 bytes, little-endian)
+      ADDRESS_SIZE = 4
+
+      # Instruction size (opcode + address)
+      INSTRUCTION_SIZE = 5
+
+      # Encode (preprocess) x86 executable data for compression.
+      #
+      # Scans for E8/E9 opcodes and converts relative addresses to
+      # absolute addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position
+      # @return [String] Encoded binary data
+      def encode(data, position = 0)
+        return data.dup if data.bytesize < INSTRUCTION_SIZE
+
+        result = data.b
+        i = 0
+        limit = data.bytesize - INSTRUCTION_SIZE
+
+        while i <= limit
+          opcode = result.getbyte(i)
+
+          # Check for CALL or JMP instruction
+          if [OPCODE_CALL, OPCODE_JMP].include?(opcode)
+            # Extract relative offset (4 bytes, little-endian)
+            offset = extract_int32_le(result, i + 1)
+
+            # Check if this is a valid relative address
+            # Valid addresses have high byte of 0x00 or 0xFF
+            if valid_relative_address?(offset)
+              # Convert relative to absolute
+              # Address is relative to position AFTER instruction
+              absolute = offset + position + i + INSTRUCTION_SIZE
+              write_int32_le(result, i + 1, absolute)
+            end
+
+            # Skip past this instruction
+            i += INSTRUCTION_SIZE
+          else
+            i += 1
+          end
+        end
+
+        result
+      end
+
+      # Decode (postprocess) x86 executable data after decompression.
+      #
+      # Reverses the encoding by converting absolute addresses back to
+      # relative addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position
+      # @return [String] Decoded binary data
+      def decode(data, position = 0)
+        return data.dup if data.bytesize < INSTRUCTION_SIZE
+
+        result = data.b
+        i = 0
+        limit = data.bytesize - INSTRUCTION_SIZE
+
+        while i <= limit
+          opcode = result.getbyte(i)
+
+          # Check for CALL or JMP instruction
+          if [OPCODE_CALL, OPCODE_JMP].include?(opcode)
+            # Extract absolute address (4 bytes, little-endian)
+            absolute = extract_int32_le(result, i + 1)
+
+            # Calculate relative offset
+            # Offset should be relative to position AFTER instruction
+            offset = absolute - (position + i + INSTRUCTION_SIZE)
+
+            # Check if result is a valid relative address
+            if valid_relative_address?(offset)
+              write_int32_le(result, i + 1, offset)
+            end
+
+            # Skip past this instruction
+            i += INSTRUCTION_SIZE
+          else
+            i += 1
+          end
+        end
+
+        result
+      end
+
+      class << self
+        # Get metadata about this filter.
+        #
+        # @return [Hash] Filter metadata
+        def metadata
+          {
+            name: "BCJ-x86",
+            description: "Branch/Call/Jump converter for x86/x64 " \
+                         "executables",
+            architecture: "x86/x64",
+          }
+        end
+      end
+
+      private
+
+      # Extract a signed 32-bit little-endian integer from data.
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Starting position
+      # @return [Integer] Signed 32-bit integer
+      def extract_int32_le(data, offset)
+        bytes = data.byteslice(offset, ADDRESS_SIZE).bytes
+        value = bytes[0] |
+          (bytes[1] << 8) |
+          (bytes[2] << 16) |
+          (bytes[3] << 24)
+
+        # Convert to signed integer
+        value >= 0x80000000 ? value - 0x100000000 : value
+      end
+
+      # Write a signed 32-bit little-endian integer to data.
+      #
+      # @param data [String] Binary data (modified in place)
+      # @param offset [Integer] Starting position
+      # @param value [Integer] Signed 32-bit integer to write
+      # @return [void]
+      def write_int32_le(data, offset, value)
+        # Convert to unsigned 32-bit
+        unsigned = value & 0xFFFFFFFF
+
+        data.setbyte(offset, unsigned & 0xFF)
+        data.setbyte(offset + 1, (unsigned >> 8) & 0xFF)
+        data.setbyte(offset + 2, (unsigned >> 16) & 0xFF)
+        data.setbyte(offset + 3, (unsigned >> 24) & 0xFF)
+      end
+
+      # Check if an address value is a valid relative address.
+      #
+      # Valid relative addresses have a high byte of 0x00 (small positive)
+      # or 0xFF (small negative). This indicates they are likely valid
+      # relative jumps within executable code.
+      #
+      # @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
+        # Only 0x00 (positive) or 0xFF (negative) are valid
+        [0x00, 0xFF].include?(high_byte)
+      end
+    end
+  end
+end

data/lib/omnizip/filters/delta.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024-2025 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
+    # Delta filter for multimedia and database preprocessing.
+    #
+    # This filter computes byte-wise differences between adjacent bytes
+    # at a specified distance. It is particularly effective for
+    # multimedia files (WAV, BMP) and database dumps where adjacent
+    # bytes often have small differences.
+    #
+    # The filter uses wrap-around arithmetic (modulo 256) and is
+    # fully reversible.
+    #
+    # Filter IDs by format:
+    # - XZ: 0x03
+    # - 7-Zip: 0x03
+    class Delta < ::Omnizip::Filter
+      # Default distance for delta calculation (audio/single channel)
+      DEFAULT_DISTANCE = 1
+
+      # Maximum allowed distance value
+      MAX_DISTANCE = 256
+
+      # Byte modulo for wrap-around arithmetic
+      BYTE_MODULO = 256
+
+      # Filter ID for XZ format
+      XZ_FILTER_ID = 0x03
+
+      # Filter ID for 7-Zip format
+      SEVEN_ZIP_FILTER_ID = 0x03
+
+      attr_reader :distance
+
+      # Initialize Delta filter with specified distance.
+      #
+      # Supports both positional and keyword argument styles:
+      #   Delta.new(3)           # positional
+      #   Delta.new(distance: 3) # keyword
+      #
+      # @param distance [Integer] Byte distance for delta calculation
+      #   - 1: Audio/single channel data
+      #   - 2: Stereo 16-bit audio
+      #   - 3: RGB image data (24-bit)
+      #   - 4: RGBA image data (32-bit) or 32-bit integers
+      # @raise [ArgumentError] If distance is invalid
+      def initialize(distance_arg = DEFAULT_DISTANCE,
+distance: DEFAULT_DISTANCE)
+        # Support both positional and keyword argument styles
+        # If called with Delta.new(3), distance_arg=3, distance=DEFAULT (keyword not used)
+        # If called with Delta.new(distance: 3), distance_arg=DEFAULT, distance=3
+        dist = if distance == DEFAULT_DISTANCE
+                 distance_arg
+               else
+                 distance
+               end
+
+        validate_distance(dist)
+        @distance = dist
+        super(architecture: :delta, name: "Delta")
+      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
+      def id_for_format(format)
+        case format
+        when :seven_zip
+          SEVEN_ZIP_FILTER_ID
+        when :xz
+          XZ_FILTER_ID
+        else
+          raise ArgumentError,
+                "Unknown format: #{format}. Supported: :seven_zip, :xz"
+        end
+      end
+
+      # Encode (preprocess) data by computing forward differences.
+      #
+      # For each byte at position i >= distance:
+      #   new[i] = (old[i] - old[i - distance]) mod 256
+      #
+      # Bytes before the distance remain unchanged (no previous value).
+      #
+      # @param data [String] Binary data to encode
+      # @param position [Integer] Current stream position (unused for
+      #   Delta)
+      # @return [String] Encoded binary data
+      def encode(data, _position = 0)
+        return data.dup if data.empty?
+
+        source = data.b
+        result = data.b
+        size = data.bytesize
+
+        # Process bytes starting from distance
+        distance.upto(size - 1) do |i|
+          current = source.getbyte(i)
+          previous = source.getbyte(i - distance)
+          # Compute difference with wrap-around
+          diff = (current - previous) & 0xFF
+          result.setbyte(i, diff)
+        end
+
+        result
+      end
+
+      # Decode (postprocess) data by restoring from differences.
+      #
+      # For each byte at position i >= distance:
+      #   old[i] = (new[i] + old[i - distance]) mod 256
+      #
+      # Bytes before the distance remain unchanged (already original).
+      #
+      # @param data [String] Binary data to decode
+      # @param position [Integer] Current stream position (unused for
+      #   Delta)
+      # @return [String] Decoded binary data
+      def decode(data, _position = 0)
+        return data.dup if data.empty?
+
+        source = data.b
+        result = data.b
+        size = data.bytesize
+
+        # Process bytes starting from distance
+        distance.upto(size - 1) do |i|
+          diff = source.getbyte(i)
+          previous = result.getbyte(i - distance)
+          # Restore original value with wrap-around
+          original = (diff + previous) & 0xFF
+          result.setbyte(i, original)
+        end
+
+        result
+      end
+
+      class << self
+        # Get metadata about this filter.
+        #
+        # @return [Hash] Filter metadata
+        def metadata
+          {
+            name: "Delta",
+            description: "Byte-wise difference filter for multimedia " \
+                         "and database preprocessing",
+            typical_usage: "WAV audio, BMP images, database dumps",
+          }
+        end
+      end
+
+      private
+
+      # Validate distance parameter.
+      #
+      # @param dist [Integer] Distance value to validate
+      # @raise [ArgumentError] If distance is invalid
+      # @return [void]
+      def validate_distance(dist)
+        unless dist.is_a?(Integer)
+          raise ArgumentError, "Distance must be an integer"
+        end
+
+        if dist < 1
+          raise ArgumentError,
+                "Distance must be at least 1, got #{dist}"
+        end
+
+        return unless dist > MAX_DISTANCE
+
+        raise ArgumentError,
+              "Distance must not exceed #{MAX_DISTANCE}, got #{dist}"
+      end
+    end
+  end
+end