omnizip 0.3.1

data/lib/omnizip/converter/zip_to_seven_zip_strategy.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "conversion_strategy"
+
+module Omnizip
+  module Converter
+    # Convert ZIP archives to 7-Zip format
+    class ZipToSevenZipStrategy < ConversionStrategy
+      # Perform ZIP to 7z conversion
+      # @return [ConversionResult] Conversion result
+      def convert
+        start_time = Time.now
+        entry_count = 0
+
+        require_relative "../zip/file"
+        require_relative "../formats/seven_zip"
+
+        # Open source ZIP archive
+        Omnizip::Zip::File.open(source_path) do |zip|
+          # Collect all entries and their data
+          entries_data = collect_entries(zip)
+          entry_count = entries_data.size
+
+          # Create target 7z archive
+          create_seven_zip(entries_data)
+        end
+
+        create_result(start_time, entry_count)
+      end
+
+      # Get source format
+      # @return [Symbol] Source format (:zip)
+      def source_format
+        :zip
+      end
+
+      # Get target format
+      # @return [Symbol] Target format (:seven_zip)
+      def target_format
+        :seven_zip
+      end
+
+      # Check if can convert
+      # @param source [String] Source file
+      # @param target [String] Target file
+      # @return [Boolean] True if can convert
+      def self.can_convert?(source, target)
+        source.end_with?(".zip") && target.end_with?(".7z")
+      end
+
+      private
+
+      def collect_entries(zip)
+        entries = []
+
+        zip.entries.each do |entry|
+          data = {
+            name: entry.name,
+            directory: entry.directory?,
+            mtime: entry.time,
+            content: nil,
+          }
+
+          unless entry.directory?
+            data[:content] = zip.get_input_stream(entry)
+
+            if options.preserve_metadata && entry.unix_perms.positive?
+              data[:unix_perms] = entry.unix_perms
+            end
+          end
+
+          entries << data
+        end
+
+        entries
+      end
+
+      def create_seven_zip(entries)
+        writer = Omnizip::Formats::SevenZip::Writer.new(target_path)
+
+        # Set compression options
+        compression = options.compression || :lzma2
+        level = options.compression_level || 5
+        options.solid.nil? || options.solid
+
+        # Add each entry
+        entries.each do |entry_data|
+          if entry_data[:directory]
+            # 7z doesn't have explicit directory entries
+            # Directories are implied by file paths
+            next
+          end
+
+          writer.add_data(
+            entry_data[:name],
+            entry_data[:content],
+            algorithm: compression,
+            level: level,
+          )
+        end
+
+        # Apply filter if specified
+        if options.filter
+          add_warning("Filters not yet supported in 7z conversion")
+        end
+
+        # Write the archive
+        writer.write
+      end
+    end
+  end
+end

data/lib/omnizip/converter.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "models/conversion_options"
+require_relative "models/conversion_result"
+require_relative "converter/conversion_strategy"
+require_relative "converter/zip_to_seven_zip_strategy"
+require_relative "converter/seven_zip_to_zip_strategy"
+require_relative "converter/conversion_registry"
+
+module Omnizip
+  # Archive format conversion module
+  # Provides conversion between different archive formats
+  module Converter
+    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
+
+        # 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
+
+      def create_options(**options)
+        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,100 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+
+require "openssl"
+require_relative "constants"
+
+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")
+          cipher.send(mode)  # Call encrypt or decrypt first
+          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,101 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+
+require "digest/sha2"
+require_relative "constants"
+
+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"
+require_relative "aes256/constants"
+require_relative "aes256/key_derivation"
+require_relative "aes256/cipher"
+
+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
+      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/error.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+
+module Omnizip
+  # Base error class for all Omnizip errors
+  class Error < StandardError
+  end
+
+  # Error raised when compression fails
+  class CompressionError < Error
+  end
+
+  # Error raised when decompression fails
+  class DecompressionError < Error
+  end
+
+  # Error raised when an algorithm is not found
+  class AlgorithmNotFoundError < Error
+  end
+
+  # Error raised when an unknown algorithm is requested
+  class UnknownAlgorithmError < Error
+  end
+
+  # Error raised when a format is not supported
+  class UnsupportedFormatError < Error
+  end
+
+  # Error raised when format parsing fails
+  class FormatError < Error
+  end
+
+  # Error raised when archive is invalid
+  class InvalidArchiveError < Error
+  end
+
+  # Error raised when I/O operations fail
+  class IOError < Error
+  end
+
+  # Error raised when checksum validation fails
+  class ChecksumError < Error
+  end
+
+  # Error raised when optimization strategy is not found
+  class OptimizationNotFound < Error
+  end
+
+  # Error raised when progress tracking fails
+  class ProgressError < Error
+  end
+
+  # Error raised when ETA calculation fails
+  class ETAError < Error
+  end
+
+  # Error raised when RAR write is attempted without license
+  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
+
+  # Error raised when RAR executable is not found
+  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