omnizip 0.4.7-arm-linux

data/lib/omnizip/formats/rar/rar5/encryption/aes256_cbc.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module Encryption
+          # AES-256-CBC cipher for RAR5 encryption
+          #
+          # Wrapper around the existing Crypto::Aes256::Cipher that provides
+          # RAR5-specific encryption/decryption with proper key and IV handling.
+          #
+          # RAR5 uses:
+          # - AES-256 in CBC mode
+          # - PKCS#7 padding
+          # - Per-file IV generation
+          # - PBKDF2-HMAC-SHA256 key derivation
+          #
+          # @example Encrypt file data
+          #   cipher = Aes256Cbc.new(key, iv)
+          #   encrypted = cipher.encrypt(data)
+          class Aes256Cbc
+            # IV size (16 bytes = AES block size)
+            IV_SIZE = 16
+
+            # Key size (32 bytes for AES-256)
+            KEY_SIZE = 32
+
+            # @return [String] AES-256 key (32 bytes)
+            attr_reader :key
+
+            # @return [String] Initialization vector (16 bytes)
+            attr_reader :iv
+
+            # Initialize cipher with key and IV
+            #
+            # @param key [String] 32-byte AES-256 key
+            # @param iv [String] 16-byte initialization vector
+            # @raise [ArgumentError] If key or IV wrong size
+            def initialize(key, iv)
+              validate_key_iv(key, iv)
+              @key = key
+              @iv = iv
+              @cipher = Crypto::Aes256::Cipher.new(key, iv)
+            end
+
+            # Encrypt data
+            #
+            # @param plaintext [String] Data to encrypt
+            # @return [String] Encrypted data (with PKCS#7 padding)
+            def encrypt(plaintext)
+              @cipher.encrypt(plaintext)
+            end
+
+            # Decrypt data
+            #
+            # @param ciphertext [String] Encrypted data
+            # @return [String] Decrypted data (padding removed)
+            def decrypt(ciphertext)
+              @cipher.decrypt(ciphertext)
+            end
+
+            # Generate random IV
+            #
+            # @return [String] 16-byte random IV
+            def self.generate_iv
+              SecureRandom.random_bytes(IV_SIZE)
+            end
+
+            private
+
+            # Validate key and IV sizes
+            #
+            # @param key [String] Key to validate
+            # @param iv [String] IV to validate
+            # @return [void]
+            # @raise [ArgumentError] If key or IV wrong size
+            def validate_key_iv(key, iv)
+              if key.bytesize != KEY_SIZE
+                raise ArgumentError,
+                      "Key must be #{KEY_SIZE} bytes, got #{key.bytesize}"
+              end
+
+              return unless iv.bytesize != IV_SIZE
+
+              raise ArgumentError,
+                    "IV must be #{IV_SIZE} bytes, got #{iv.bytesize}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/rar5/encryption/encryption_header.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+begin
+  require "lutaml/model"
+rescue LoadError, ArgumentError
+  # lutaml-model not available, using simple classes
+end
+
+require "base64"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module Encryption
+          # RAR5 encryption header
+          #
+          # This model stores encryption parameters needed for password verification
+          # and decryption. The header is written at the beginning of encrypted
+          # archive sections.
+          #
+          # RAR5 encryption header contains:
+          # - Version (always 0 for AES-256)
+          # - KDF iteration count
+          # - Salt for key derivation
+          # - IV for AES-CBC
+          # - Check value for password verification
+          #
+          # @example Create encryption header
+          #   header = EncryptionHeader.new(
+          #     version: 0,
+          #     kdf_iterations: 262_144,
+          #     salt: salt,
+          #     iv: iv,
+          #     check_value: check
+          #   )
+          class EncryptionHeader < Lutaml::Model::Serializable
+            # Encryption version (0 for AES-256)
+            attribute :version, :integer, default: 0
+
+            # PBKDF2 iteration count
+            attribute :kdf_iterations, :integer, default: 262_144
+
+            # Salt for key derivation (16 bytes, base64 encoded for serialization)
+            attribute :salt, :string
+
+            # Initialization vector (16 bytes, base64 encoded for serialization)
+            attribute :iv, :string
+
+            # Password check value (first 8 bytes of encrypted data)
+            # Used to verify password before full decryption
+            attribute :check_value, :string
+
+            # Validate header
+            #
+            # @raise [ArgumentError] If validation fails
+            def validate!
+              if version != 0
+                raise ArgumentError, "Only AES-256 (version 0) is supported"
+              end
+
+              if kdf_iterations < 65_536 || kdf_iterations > 1_048_576
+                raise ArgumentError,
+                      "KDF iterations must be between 65,536 and 1,048,576"
+              end
+
+              # Validate salt (base64 decoded should be 16 bytes)
+              decoded_salt = Base64.strict_decode64(salt)
+              if decoded_salt.bytesize != 16
+                raise ArgumentError, "Salt must be 16 bytes"
+              end
+
+              # Validate IV (base64 decoded should be 16 bytes)
+              decoded_iv = Base64.strict_decode64(iv)
+              if decoded_iv.bytesize != 16
+                raise ArgumentError, "IV must be 16 bytes"
+              end
+            rescue ArgumentError => e
+              raise ArgumentError, "Invalid encryption header: #{e.message}"
+            end
+
+            # Get salt as binary
+            #
+            # @return [String] 16-byte binary salt
+            def salt_binary
+              Base64.strict_decode64(salt)
+            end
+
+            # Get IV as binary
+            #
+            # @return [String] 16-byte binary IV
+            def iv_binary
+              Base64.strict_decode64(iv)
+            end
+
+            # Set salt from binary
+            #
+            # @param binary_salt [String] 16-byte binary salt
+            def salt_binary=(binary_salt)
+              self.salt = Base64.strict_encode64(binary_salt)
+            end
+
+            # Set IV from binary
+            #
+            # @param binary_iv [String] 16-byte binary IV
+            def iv_binary=(binary_iv)
+              self.iv = Base64.strict_encode64(binary_iv)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/rar5/encryption/encryption_manager.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module Encryption
+          # Encryption manager for RAR5 archives
+          #
+          # This manager coordinates the encryption process:
+          # 1. Generate salt and IV
+          # 2. Derive key from password using PBKDF2
+          # 3. Encrypt file data with AES-256-CBC
+          # 4. Create encryption header with metadata
+          #
+          # @example Encrypt file data
+          #   manager = EncryptionManager.new("SecurePassword", kdf_iterations: 262_144)
+          #   result = manager.encrypt_file_data(file_data)
+          #   # result[:encrypted_data] = encrypted bytes
+          #   # result[:header] = EncryptionHeader with salt, IV, etc.
+          class EncryptionManager
+            # @return [String] Password for encryption
+            attr_reader :password
+
+            # @return [Integer] PBKDF2 iteration count
+            attr_reader :kdf_iterations
+
+            # @return [String, nil] Optional pre-generated salt
+            attr_reader :salt
+
+            # @return [String, nil] Optional pre-generated IV
+            attr_reader :iv
+
+            # Initialize encryption manager
+            #
+            # @param password [String] Encryption password
+            # @param options [Hash] Options
+            # @option options [Integer] :kdf_iterations PBKDF2 iterations (default: 262,144)
+            # @option options [String] :salt Pre-generated salt (16 bytes, optional)
+            # @option options [String] :iv Pre-generated IV (16 bytes, optional)
+            def initialize(password, options = {})
+              @password = password
+              @kdf_iterations = options[:kdf_iterations] || KeyDerivation::DEFAULT_ITERATIONS
+              @salt = options[:salt]
+              @iv = options[:iv]
+
+              validate_password!
+              validate_iterations!
+            end
+
+            # Encrypt file data
+            #
+            # @param plaintext [String] File data to encrypt
+            # @return [Hash] Encryption result
+            # @option result [String] :encrypted_data Encrypted bytes
+            # @option result [EncryptionHeader] :header Encryption metadata
+            # @option result [String] :key Derived encryption key (for debugging)
+            def encrypt_file_data(plaintext)
+              # Generate or use provided salt and IV
+              salt = @salt || KeyDerivation.generate_salt
+              iv = @iv || Aes256Cbc.generate_iv
+
+              # Derive key from password
+              key = KeyDerivation.derive_key(@password, salt, @kdf_iterations)
+
+              # Encrypt data
+              cipher = Aes256Cbc.new(key, iv)
+              encrypted = cipher.encrypt(plaintext)
+
+              # Create encryption header
+              header = create_encryption_header(salt, iv)
+
+              {
+                encrypted_data: encrypted,
+                header: header,
+                key: key, # Include for verification if needed
+              }
+            end
+
+            # Decrypt file data
+            #
+            # @param ciphertext [String] Encrypted data
+            # @param header [EncryptionHeader] Encryption metadata
+            # @return [String] Decrypted data
+            # @raise [ArgumentError] If password incorrect
+            def decrypt_file_data(ciphertext, header)
+              # Extract salt and IV
+              salt = header.salt_binary
+              iv = header.iv_binary
+
+              # Derive key from password
+              key = KeyDerivation.derive_key(@password, salt,
+                                             header.kdf_iterations)
+
+              # Decrypt data
+              cipher = Aes256Cbc.new(key, iv)
+              cipher.decrypt(ciphertext)
+            rescue OpenSSL::Cipher::CipherError => e
+              raise ArgumentError,
+                    "Decryption failed (wrong password?): #{e.message}"
+            end
+
+            # Verify password without full decryption
+            #
+            # This checks if the derived key can decrypt the check value.
+            # Faster than decrypting entire file.
+            #
+            # @param header [EncryptionHeader] Encryption metadata
+            # @return [Boolean] true if password correct
+            def verify_password(_header)
+              # For now, we'll need a small encrypted sample to verify
+              # This is a simplified check - full implementation would use
+              # the check_value field properly
+              true # Placeholder
+            rescue StandardError
+              false
+            end
+
+            private
+
+            # Create encryption header
+            #
+            # @param salt [String] 16-byte salt
+            # @param iv [String] 16-byte IV
+            # @return [EncryptionHeader] Header object
+            def create_encryption_header(salt, iv)
+              header = EncryptionHeader.new
+              header.version = 0 # AES-256
+              header.kdf_iterations = @kdf_iterations
+              header.salt_binary = salt
+              header.iv_binary = iv
+              header.check_value = "" # Placeholder for password check
+              header
+            end
+
+            # Validate password
+            #
+            # @raise [ArgumentError] If password invalid
+            def validate_password!
+              if @password.nil? || @password.empty?
+                raise ArgumentError, "Password cannot be empty"
+              end
+            end
+
+            # Validate iteration count
+            #
+            # @raise [ArgumentError] If iterations invalid
+            def validate_iterations!
+              min = KeyDerivation::MIN_ITERATIONS
+              max = KeyDerivation::MAX_ITERATIONS
+
+              return if @kdf_iterations.between?(min, max)
+
+              raise ArgumentError,
+                    "KDF iterations must be between #{min} and #{max}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/rar5/encryption/key_derivation.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "securerandom"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        module Encryption
+          # RAR5 password-based key derivation
+          #
+          # RAR5 uses PBKDF2-HMAC-SHA256 for key derivation, which is more
+          # secure than 7-Zip's iterative SHA-256 approach.
+          #
+          # The process:
+          # 1. Generate random salt (16 bytes)
+          # 2. Apply PBKDF2-HMAC-SHA256 with configurable iterations
+          # 3. Derive 32-byte AES-256 key
+          #
+          # @example Derive key from password
+          #   salt = SecureRandom.random_bytes(16)
+          #   key = KeyDerivation.derive_key("password", salt, 262_144)
+          class KeyDerivation
+            # Default PBKDF2 iterations (262,144 = 2^18)
+            # This provides good security while maintaining reasonable performance
+            DEFAULT_ITERATIONS = 262_144
+
+            # Minimum iterations (2^16 = 65,536)
+            MIN_ITERATIONS = 65_536
+
+            # Maximum iterations (2^20 = 1,048,576)
+            MAX_ITERATIONS = 1_048_576
+
+            # Salt size (16 bytes)
+            SALT_SIZE = 16
+
+            # Key size (32 bytes for AES-256)
+            KEY_SIZE = 32
+
+            # Derive AES-256 key from password using PBKDF2-HMAC-SHA256
+            #
+            # @param password [String] User password
+            # @param salt [String] Random salt (16 bytes)
+            # @param iterations [Integer] Number of PBKDF2 iterations
+            # @return [String] 32-byte AES-256 key
+            # @raise [ArgumentError] If password empty or salt wrong size
+            def self.derive_key(password, salt, iterations = DEFAULT_ITERATIONS)
+              validate_inputs(password, salt, iterations)
+
+              # PBKDF2-HMAC-SHA256
+              OpenSSL::PKCS5.pbkdf2_hmac(
+                password,
+                salt,
+                iterations,
+                KEY_SIZE,
+                OpenSSL::Digest.new("SHA256"),
+              )
+            end
+
+            # Generate random salt
+            #
+            # @return [String] 16-byte random salt
+            def self.generate_salt
+              SecureRandom.random_bytes(SALT_SIZE)
+            end
+
+            # Validate key derivation inputs
+            #
+            # @param password [String] Password to validate
+            # @param salt [String] Salt to validate
+            # @param iterations [Integer] Iteration count to validate
+            # @return [void]
+            # @raise [ArgumentError] If inputs are invalid
+            def self.validate_inputs(password, salt, iterations)
+              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, got #{salt.bytesize}"
+              end
+
+              return if iterations.between?(MIN_ITERATIONS, MAX_ITERATIONS)
+
+              raise ArgumentError,
+                    "Iterations must be between #{MIN_ITERATIONS} and #{MAX_ITERATIONS}"
+            end
+
+            private_class_method :validate_inputs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/rar5/header.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Rar5
+        # Header types
+        HEADER_TYPE_MAIN = 1
+        HEADER_TYPE_FILE = 2
+        HEADER_TYPE_SERVICE = 3
+        HEADER_TYPE_ENCRYPTION = 4
+        HEADER_TYPE_END = 5
+
+        # Header flags (common)
+        FLAG_EXTRA_AREA = 0x0001
+        FLAG_DATA_AREA = 0x0002
+
+        # Base class for RAR5 headers
+        class Header
+          attr_reader :type, :flags, :extra_area, :data_area_size, :header_data
+
+          def initialize(type, flags: 0, extra_area: nil, data_area_size: nil,
+header_data: "")
+            @type = type
+            @flags = flags
+            @flags |= FLAG_EXTRA_AREA if extra_area
+            @flags |= FLAG_DATA_AREA if data_area_size
+            @extra_area = extra_area
+            @data_area_size = data_area_size
+            @header_data = header_data
+          end
+
+          def encode
+            # Build header without CRC
+            header_bytes = build_header_bytes
+
+            # Calculate CRC32
+            crc = CRC32.calculate(header_bytes.pack("C*"))
+
+            # Prepend CRC (little-endian)
+            [crc].pack("V") + header_bytes.pack("C*")
+          end
+
+          private
+
+          def build_header_bytes
+            bytes = []
+
+            # Header size (placeholder - will calculate)
+            size_bytes = []
+
+            # Type
+            type_bytes = VINT.encode(@type)
+            size_bytes.concat(type_bytes)
+
+            # Flags
+            flags_bytes = VINT.encode(@flags)
+            size_bytes.concat(flags_bytes)
+
+            # Extra area size (if present)
+            if @flags.anybits?(FLAG_EXTRA_AREA)
+              extra_size_bytes = VINT.encode(@extra_area.bytesize)
+              size_bytes.concat(extra_size_bytes)
+            end
+
+            # Data area size (if present)
+            if @flags.anybits?(FLAG_DATA_AREA)
+              data_size_bytes = VINT.encode(@data_area_size)
+              size_bytes.concat(data_size_bytes)
+            end
+
+            # Header data
+            size_bytes.concat(@header_data.bytes)
+
+            # Extra area
+            size_bytes.concat(@extra_area.bytes) if @extra_area
+
+            # Calculate total header size (excluding CRC)
+            header_size = size_bytes.size
+            header_size_vint = VINT.encode(header_size)
+
+            # Build final header
+            bytes.concat(header_size_vint)
+            bytes.concat(size_bytes)
+
+            bytes
+          end
+        end
+
+        # Main archive header
+        class MainHeader < Header
+          # Archive flags: 0x0001 volume, 0x0002 volume number
+          # present, 0x0004 solid, 0x0008 recovery, 0x0010 locked
+          ARCHIVE_FLAG_VOLUME = 0x0001
+          ARCHIVE_FLAG_VOLUME_NUMBER = 0x0002
+
+          def initialize(archive_flags: 0, volume_number: nil)
+            data = VINT.encode(archive_flags)
+            if archive_flags.anybits?(ARCHIVE_FLAG_VOLUME_NUMBER)
+              data.concat(VINT.encode(volume_number.to_i))
+            end
+
+            super(HEADER_TYPE_MAIN, header_data: data.pack("C*"))
+          end
+        end
+
+        # File header
+        class FileHeader < Header
+          # File header flags. Per the RAR 5.0 spec, 0x0001 marks a
+          # directory entry (what this codebase once mislabeled as
+          # "has attributes" — attributes are an always-present field)
+          FILE_IS_DIRECTORY = 0x0001
+          FILE_HAS_MTIME = 0x0002
+          FILE_HAS_CRC32 = 0x0004
+
+          # Compression information field layout (RAR 5.0 spec):
+          # bits 0-5 algorithm version (0), bit 7 solid,
+          # bits 8-10 method (0=store, 1-5=LZMA), bits 11-15
+          # dictionary size (128 KB * 2^N).
+          DICT_BASE = 128 * 1024
+
+          def initialize(filename:, file_size:, compressed_size:,
+                         compression_method: 0, dict_size: 0,
+                         flags: 0, mtime: nil, crc32: nil,
+                         directory: false, extra_area: nil)
+            # Build file flags based on what's provided
+            file_flags = 0
+            file_flags |= FILE_IS_DIRECTORY if directory
+            file_flags |= FILE_HAS_MTIME if mtime
+            file_flags |= FILE_HAS_CRC32 if crc32
+
+            # Build header data with file information
+            data = build_file_data(filename, file_size,
+                                   compression_method, dict_size,
+                                   file_flags, mtime, crc32,
+                                   directory: directory)
+            super(HEADER_TYPE_FILE, flags: flags, data_area_size: compressed_size, header_data: data, extra_area: extra_area)
+          end
+
+          private
+
+          def build_file_data(filename, file_size, compression_method,
+                              dict_size, file_flags, mtime, crc32,
+                              directory: false)
+            data = []
+
+            # File flags (VINT)
+            data.concat(VINT.encode(file_flags))
+
+            # Unpacked size (VINT)
+            data.concat(VINT.encode(file_size))
+
+            # Attributes (VINT) - ALWAYS present in RAR5.
+            # Unix host: directory mode for directory entries,
+            # regular-file 0o100644 otherwise.
+            data.concat(VINT.encode(directory ? 0o040755 : 0o100644))
+
+            # mtime (optional) - only if FILE_HAS_MTIME flag is set
+            # RAR5 stores mtime as Unix timestamp (seconds since epoch)
+            # Format: 4 bytes little-endian (NOT a VINT)
+            if file_flags.anybits?(FILE_HAS_MTIME) && mtime
+              data.concat([mtime.to_i].pack("V").bytes)
+            end
+
+            # Data CRC32 (optional) - only if FILE_HAS_CRC32 flag is set
+            # Format: 4 bytes little-endian (NOT a VINT)
+            if file_flags.anybits?(FILE_HAS_CRC32) && crc32
+              data.concat([crc32].pack("V").bytes)
+            end
+
+            # Compression information (VINT): version 0 in bits 0-5,
+            # method in bits 8-10, dictionary size in bits 11-15
+            # (128 KB * 2^N).
+            dict_bits = if dict_size.positive?
+                          Math.log2(dict_size / DICT_BASE).round.clamp(0, 15)
+                        else
+                          0
+                        end
+            compression_info = (compression_method << 8) | (dict_bits << 11)
+            data.concat(VINT.encode(compression_info))
+
+            # Host OS (VINT) - 1 = Unix
+            data.concat(VINT.encode(1))
+
+            # Name length (VINT) and name
+            name_bytes = filename.encode("UTF-8").bytes
+            data.concat(VINT.encode(name_bytes.size))
+            data.concat(name_bytes)
+
+            data.pack("C*")
+          end
+        end
+
+        # End of archive header
+        class EndHeader < Header
+          # End of archive flags: 0x0001 volume and not the last
+          # volume in the set
+          END_FLAG_VOLUME_NEXT = 0x0001
+
+          def initialize(end_flags: 0)
+            super(HEADER_TYPE_END,
+                  header_data: VINT.encode(end_flags).pack("C*"))
+          end
+        end
+      end
+    end
+  end
+end