omnizip 0.4.7-arm-linux

data/lib/omnizip/converter.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Archive format conversion module
+  # Provides conversion between different archive formats
+  module Converter
+    # Nested classes - autoloaded
+    autoload :ConversionStrategy, "omnizip/converter/conversion_strategy"
+    autoload :ZipToSevenZipStrategy,
+             "omnizip/converter/zip_to_seven_zip_strategy"
+    autoload :SevenZipToZipStrategy,
+             "omnizip/converter/seven_zip_to_zip_strategy"
+    autoload :ConversionRegistry, "omnizip/converter/conversion_registry"
+    autoload :ExtractRepackStrategy,
+             "omnizip/converter/extract_repack_strategy"
+
+    class << self
+      # Convert archive from one format to another
+      # @param source_path [String] Source archive path
+      # @param target_path [String] Target archive path
+      # @param options [Hash, ConversionOptions] Conversion options
+      # @return [ConversionResult] Conversion result
+      def convert(source_path, target_path, **options)
+        # Find appropriate strategy first
+        strategy_class = ConversionRegistry.find_strategy(source_path,
+                                                          target_path)
+        unless strategy_class
+          raise ArgumentError, "No conversion strategy available for " \
+                               "#{source_path} -> #{target_path}"
+        end
+
+        # Then validate input files
+        unless File.exist?(source_path)
+          raise Errno::ENOENT, "Source file not found: #{source_path}"
+        end
+
+        # Create options object
+        opts = options.is_a?(Models::ConversionOptions) ? options : create_options(**options)
+        opts.validate_options!
+
+        # Perform conversion
+        strategy = strategy_class.new(source_path, target_path, opts)
+        result = strategy.convert
+
+        # Delete source if requested
+        File.delete(source_path) if opts.delete_source && File.exist?(source_path)
+
+        result
+      end
+
+      # Convert with explicit options object
+      # @param source_path [String] Source archive path
+      # @param target_path [String] Target archive path
+      # @param options [ConversionOptions] Conversion options
+      # @return [ConversionResult] Conversion result
+      def convert_with_options(source_path, target_path, options)
+        convert(source_path, target_path, options)
+      end
+
+      # Check if conversion is supported
+      # @param source_path [String] Source archive path
+      # @param target_path [String] Target archive path
+      # @return [Boolean] True if conversion is supported
+      def supported?(source_path, target_path)
+        ConversionRegistry.supported?(source_path, target_path)
+      end
+
+      # Get available conversion strategies
+      # @return [Array<Class>] List of strategy classes
+      def strategies
+        ConversionRegistry.strategies
+      end
+
+      # Batch convert multiple archives
+      # @param sources [Array<String>] Source file paths
+      # @param target_format [Symbol] Target format (:zip or :seven_zip)
+      # @param options [Hash] Conversion options
+      # @yield [result] Optional block called for each conversion
+      # @return [Array<ConversionResult>] Conversion results
+      def batch_convert(sources, target_format: :seven_zip, **options, &block)
+        results = []
+
+        sources.each do |source|
+          target = generate_target_path(source, target_format)
+          result = convert(source, target, target_format: target_format,
+                                           **options)
+          results << result
+          yield(result) if block
+        end
+
+        results
+      end
+
+      private
+
+      # Build a ConversionOptions model from caller-supplied keywords.
+      #
+      # lutaml-model silently discards unknown constructor keys, so a
+      # mistyped option (e.g. +level:+ instead of +compression_level:+)
+      # would fall back to defaults without warning. Reject unknown keys
+      # up front instead.
+      #
+      # @raise [ArgumentError] if any key is not a declared attribute
+      def create_options(**options)
+        known = Models::ConversionOptions.attributes.keys.map(&:to_sym)
+        unknown = options.keys.map(&:to_sym) - known
+        unless unknown.empty?
+          raise ArgumentError,
+                "Unknown option(s): #{unknown.join(', ')}. " \
+                "Valid options: #{known.join(', ')}"
+        end
+
+        Models::ConversionOptions.new(**options)
+      end
+
+      def generate_target_path(source, target_format)
+        base = File.basename(source, File.extname(source))
+        dir = File.dirname(source)
+        ext = target_format == :seven_zip ? ".7z" : ".zip"
+        File.join(dir, base + ext)
+      end
+    end
+  end
+end

data/lib/omnizip/crypto/aes256/cipher.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+
+require "openssl"
+
+module Omnizip
+  module Crypto
+    class Aes256
+      # AES-256-CBC cipher operations
+      #
+      # Wraps OpenSSL's AES-256-CBC implementation with proper
+      # padding and error handling for 7-Zip compatibility.
+      class Cipher
+        include Constants
+
+        attr_reader :key, :iv
+
+        # Initialize cipher with key and IV
+        #
+        # @param key [String] 32-byte AES-256 key
+        # @param iv [String] 16-byte initialization vector
+        def initialize(key, iv)
+          validate_key_iv(key, iv)
+          @key = key
+          @iv = iv
+        end
+
+        # Encrypt data using AES-256-CBC
+        #
+        # @param plaintext [String] Data to encrypt
+        # @return [String] Encrypted data
+        def encrypt(plaintext)
+          cipher = create_cipher(:encrypt)
+
+          # Handle empty data - just call final() for padding
+          if plaintext.empty?
+            return cipher.final
+          end
+
+          result = cipher.update(plaintext)
+          result << cipher.final
+
+          result
+        end
+
+        # Decrypt data using AES-256-CBC
+        #
+        # @param ciphertext [String] Encrypted data
+        # @return [String] Decrypted data
+        def decrypt(ciphertext)
+          cipher = create_cipher(:decrypt)
+
+          # Handle empty or very small ciphertext
+          if ciphertext.empty?
+            return ""
+          end
+
+          result = cipher.update(ciphertext)
+          result << cipher.final
+
+          result
+        end
+
+        private
+
+        # Validate key and IV parameters
+        #
+        # @param key [String] Key to validate
+        # @param iv [String] IV to validate
+        # @return [void]
+        # @raise [ArgumentError] If key or IV invalid
+        def validate_key_iv(key, iv)
+          if key.bytesize != KEY_SIZE
+            raise ArgumentError,
+                  "Key must be #{KEY_SIZE} bytes"
+          end
+          return unless iv.bytesize != IV_SIZE
+
+          raise ArgumentError,
+                "IV must be #{IV_SIZE} bytes"
+        end
+
+        # Create OpenSSL cipher instance
+        #
+        # @param mode [Symbol] :encrypt or :decrypt
+        # @return [OpenSSL::Cipher] Configured cipher
+        def create_cipher(mode)
+          cipher = OpenSSL::Cipher.new("AES-256-CBC")
+          case mode
+          when :encrypt then cipher.encrypt
+          when :decrypt then cipher.decrypt
+          else
+            raise ArgumentError, "Unknown cipher mode: #{mode.inspect}"
+          end
+          cipher.key = @key  # Then set key
+          cipher.iv = @iv    # Then set IV
+          cipher.padding = 1 # PKCS7 padding
+          cipher
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/crypto/aes256/constants.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+
+module Omnizip
+  module Crypto
+    class Aes256
+      # Constants for AES-256 encryption in 7-Zip format
+      module Constants
+        # Key size for AES-256 (32 bytes = 256 bits)
+        KEY_SIZE = 32
+
+        # Maximum salt size (16 bytes)
+        SALT_SIZE_MAX = 16
+        SALT_SIZE = 16
+
+        # IV size (16 bytes = AES block size)
+        IV_SIZE = 16
+        BLOCK_SIZE = 16
+
+        # Default number of SHA-256 cycles (2^19 = 524288)
+        DEFAULT_CYCLES_POWER = 19
+        MIN_CYCLES_POWER = 0
+        MAX_CYCLES_POWER = 24
+      end
+    end
+  end
+end

data/lib/omnizip/crypto/aes256/key_derivation.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+
+require "digest/sha2"
+
+module Omnizip
+  module Crypto
+    class Aes256
+      # 7-Zip password-based key derivation
+      #
+      # Uses SHA-256 iterative hashing to derive encryption keys
+      # from passwords. The number of iterations is 2^cycles_power.
+      class KeyDerivation
+        include Constants
+
+        # Derive AES-256 key from password
+        #
+        # This implements 7-Zip's key derivation:
+        # 1. Concatenate salt and password
+        # 2. Hash with SHA-256 for 2^cycles_power iterations
+        # 3. Extract first 32 bytes as key
+        #
+        # @param password [String] User password
+        # @param salt [String] Random salt
+        # @param cycles_power [Integer] Power of 2 for iterations
+        # @return [String] 32-byte AES-256 key
+        def self.derive_key(password, salt, cycles_power = DEFAULT_CYCLES_POWER)
+          validate_inputs(password, salt, cycles_power)
+
+          # Calculate number of iterations
+          num_cycles = 1 << cycles_power
+
+          # Initial input: salt + password (in UTF-16LE for 7-Zip compat)
+          # Force binary encoding to make concatenation work
+          encoded_password = encode_password(password).force_encoding(Encoding::BINARY)
+          input = salt.dup.force_encoding(Encoding::BINARY) + encoded_password
+
+          # Iterative SHA-256 hashing
+          key = perform_hashing(input, num_cycles)
+
+          # Return first 32 bytes
+          key[0, KEY_SIZE]
+        end
+
+        # Validate key derivation inputs
+        #
+        # @param password [String] Password to validate
+        # @param salt [String] Salt to validate
+        # @param cycles_power [Integer] Cycles power to validate
+        # @return [void]
+        # @raise [ArgumentError] If inputs are invalid
+        def self.validate_inputs(password, salt, cycles_power)
+          if password.nil? || password.empty?
+            raise ArgumentError,
+                  "Password cannot be empty"
+          end
+          if salt.bytesize != SALT_SIZE
+            raise ArgumentError,
+                  "Salt must be #{SALT_SIZE} bytes"
+          end
+
+          return if cycles_power.between?(MIN_CYCLES_POWER, MAX_CYCLES_POWER)
+
+          raise ArgumentError,
+                "Cycles power must be between #{MIN_CYCLES_POWER} and #{MAX_CYCLES_POWER}"
+        end
+
+        # Encode password to UTF-16LE (7-Zip format)
+        #
+        # @param password [String] Password in any encoding
+        # @return [String] UTF-16LE encoded password
+        def self.encode_password(password)
+          password.encode(Encoding::UTF_16LE)
+        end
+
+        # Perform iterative SHA-256 hashing
+        #
+        # @param input [String] Initial input (salt + password)
+        # @param num_cycles [Integer] Number of hash iterations
+        # @return [String] Final hash result
+        def self.perform_hashing(input, num_cycles)
+          digest = Digest::SHA256.new
+          result = input
+
+          num_cycles.times do
+            digest.reset
+            digest << result
+            result = digest.digest
+          end
+
+          result
+        end
+
+        private_class_method :validate_inputs, :encode_password,
+                             :perform_hashing
+      end
+    end
+  end
+end

data/lib/omnizip/crypto/aes256.rb

@@ -0,0 +1,102 @@
+# 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.
+
+require "openssl"
+require "digest/sha2"
+
+module Omnizip
+  module Crypto
+    # AES-256 encryption for 7-Zip archives
+    #
+    # Implements 7-Zip's AES-256-CBC encryption with:
+    # - Password-based key derivation (SHA-256)
+    # - Configurable salt and cycles
+    # - CBC mode with IV
+    #
+    # This follows 7-Zip's encryption specification.
+    class Aes256
+      autoload :Constants, "omnizip/crypto/aes256/constants"
+      autoload :KeyDerivation, "omnizip/crypto/aes256/key_derivation"
+      autoload :Cipher, "omnizip/crypto/aes256/cipher"
+      include Constants
+
+      # Encrypt data with AES-256
+      #
+      # @param data [String] Data to encrypt
+      # @param password [String] Encryption password
+      # @param options [Hash] Encryption options
+      # @option options [Integer] :num_cycles_power Power of 2 for key
+      #   derivation iterations
+      # @option options [String] :salt Random salt (auto-generated if nil)
+      # @option options [String] :iv Initialization vector
+      #   (auto-generated if nil)
+      # @return [Hash] Encrypted data with metadata
+      def self.encrypt(data, password, options = {})
+        salt = options[:salt] || generate_salt
+        iv = options[:iv] || generate_iv
+        cycles_power = options[:num_cycles_power] || DEFAULT_CYCLES_POWER
+
+        key = KeyDerivation.derive_key(password, salt, cycles_power)
+        cipher = Cipher.new(key, iv)
+
+        encrypted_data = cipher.encrypt(data)
+
+        {
+          data: encrypted_data,
+          salt: salt,
+          iv: iv,
+          cycles_power: cycles_power,
+        }
+      end
+
+      # Decrypt data with AES-256
+      #
+      # @param encrypted_data [String] Encrypted data
+      # @param password [String] Decryption password
+      # @param salt [String] Salt used during encryption
+      # @param iv [String] IV used during encryption
+      # @param cycles_power [Integer] Cycles power used during encryption
+      # @return [String] Decrypted data
+      def self.decrypt(encrypted_data, password, salt, iv, cycles_power)
+        key = KeyDerivation.derive_key(password, salt, cycles_power)
+        cipher = Cipher.new(key, iv)
+
+        cipher.decrypt(encrypted_data)
+      end
+
+      # Generate random salt
+      #
+      # @param size [Integer] Salt size in bytes (default 16)
+      # @return [String] Random salt
+      def self.generate_salt(size = SALT_SIZE)
+        OpenSSL::Random.random_bytes(size)
+      end
+
+      # Generate random IV
+      #
+      # @return [String] Random IV
+      def self.generate_iv
+        OpenSSL::Random.random_bytes(IV_SIZE)
+      end
+    end
+  end
+end

data/lib/omnizip/crypto.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Cryptographic utilities module
+  #
+  # Provides encryption and decryption capabilities for archive formats
+  # that support password protection.
+  module Crypto
+    autoload :Aes256, "omnizip/crypto/aes256"
+  end
+end

data/lib/omnizip/entry.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Mix-in that establishes the common contract every archive entry
+  # satisfies, regardless of format.
+  #
+  # Each format-specific entry class (Zip::Entry, Tar::Entry,
+  # SevenZip::Models::FileEntry, Iso::DirectoryRecord, Ole::Dirent,
+  # Xar::Entry, Rpm::Entry, Msi::Entry, Cpio::Entry, Rar3::Entry,
+  # Rar5::Entry, Metadata::EntryMetadata) includes this
+  # module so callers can rely on a single narrow interface instead
+  # of duck-typing through `respond_to?(:name) / :path / :filename`
+  # cascades.
+  #
+  # Including classes MUST override the four methods below. The
+  # defaults raise `NotImplementedError` to surface missing
+  # implementations at call time rather than at include time.
+  module Entry
+    # @return [String, nil] in-archive path, or nil if the entry has
+    #   no name (e.g. empty anti-entry)
+    def entry_name
+      raise NotImplementedError,
+            "#{self.class} must implement #entry_name"
+    end
+
+    # @return [Boolean] true if the entry is a directory
+    def entry_directory?
+      raise NotImplementedError,
+            "#{self.class} must implement #entry_directory?"
+    end
+
+    # @return [Integer, nil] uncompressed size in bytes
+    def entry_size
+      raise NotImplementedError,
+            "#{self.class} must implement #entry_size"
+    end
+
+    # @return [Time, nil] modification time
+    def entry_mtime
+      raise NotImplementedError,
+            "#{self.class} must implement #entry_mtime"
+    end
+  end
+end

data/lib/omnizip/error.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+
+module Omnizip
+  class Error < StandardError
+  end
+
+  class CompressionError < Error
+  end
+
+  class DecompressionError < Error
+  end
+
+  class AlgorithmNotFoundError < Error
+  end
+
+  # Canonical alias of +AlgorithmNotFoundError+. Older code referenced
+  # +UnknownAlgorithmError+; both names are kept for backward
+  # compatibility.
+  UnknownAlgorithmError = AlgorithmNotFoundError
+
+  class UnknownChecksumError < Error
+  end
+
+  class UnknownFilterError < Error
+  end
+
+  class UnknownEncryptionStrategyError < Error
+  end
+
+  class ConversionNotSupportedError < Error
+  end
+
+  class UnsupportedFormatError < Error
+  end
+
+  class FormatError < Error
+  end
+
+  class InvalidArchiveError < Error
+  end
+
+  # Renamed from +IOError+ to avoid shadowing Ruby's built-in IOError.
+  # The legacy name is kept as an alias.
+  class IOOperationError < Error
+  end
+  IOError = IOOperationError
+
+  class ChecksumError < Error
+  end
+
+  # Canonical name. +OptimizationNotFound+ kept as alias.
+  class OptimizationNotFoundError < Error
+  end
+  OptimizationNotFound = OptimizationNotFoundError
+
+  class ProgressError < Error
+  end
+
+  class ETAError < Error
+  end
+
+  class NotLicensedError < Error
+    def initialize(message = default_message)
+      super
+    end
+
+    private
+
+    def default_message
+      <<~MSG
+        RAR creation requires a licensed copy of WinRAR.
+
+        To use RAR creation:
+        1. Purchase a WinRAR license from https://www.rarlab.com/
+        2. Install WinRAR on your system
+        3. Confirm license ownership when prompted
+
+        Alternatively, use 7z format which provides similar compression
+        with no licensing restrictions:
+
+          Omnizip::Formats::SevenZip.create('archive.7z') do |sz|
+            sz.add_directory('files/')
+          end
+      MSG
+    end
+  end
+
+  class RarNotAvailableError < Error
+    def initialize(message = default_message)
+      super
+    end
+
+    private
+
+    def default_message
+      <<~MSG
+        WinRAR executable not found.
+
+        Please install WinRAR:
+        - Windows: Download from https://www.rarlab.com/
+        - Linux: Install 'rar' package (requires license)
+        - macOS: Install via Homebrew: brew install rar (requires license)
+
+        After installation, ensure 'rar' or 'Rar.exe' is in your PATH.
+      MSG
+    end
+  end
+end