omnizip 0.4.7-x86_64-linux

data/lib/omnizip/formats/seven_zip/encrypted_header.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Encrypted header model for .7z archives
+      # Stores metadata for header encryption
+      class EncryptedHeader
+        include Omnizip::Formats::SevenZip::Constants
+
+        attr_accessor :encrypted_data, :salt, :iv, :original_size, :crc
+
+        # Initialize encrypted header
+        #
+        # @param encrypted_data [String] Encrypted header bytes
+        # @param salt [String] PBKDF2 salt
+        # @param iv [String] AES initialization vector
+        # @param original_size [Integer] Size before encryption
+        # @param crc [Integer, nil] CRC32 of encrypted data (optional)
+        def initialize(encrypted_data: nil, salt: nil, iv: nil,
+                       original_size: 0, crc: nil)
+          @encrypted_data = encrypted_data
+          @salt = salt
+          @iv = iv
+          @original_size = original_size
+          @crc = crc
+        end
+
+        # Serialize encrypted header to binary format
+        #
+        # Format:
+        #   - 1 byte: PropertyId::ENCODED_HEADER marker
+        #   - 8 bytes: Encrypted data size (little-endian)
+        #   - 16 bytes: Salt
+        #   - 16 bytes: IV
+        #   - 8 bytes: Original size (little-endian)
+        #   - 4 bytes: CRC32 (optional, 0 if not set)
+        #   - N bytes: Encrypted data
+        #
+        # @return [String] Binary representation
+        def to_binary
+          data = String.new(encoding: "BINARY")
+
+          # Marker for encoded header
+          data << [PropertyId::ENCODED_HEADER].pack("C")
+
+          # Encrypted data size
+          data << [@encrypted_data.bytesize].pack("Q<")
+
+          # Encryption parameters
+          data << @salt
+          data << @iv
+
+          # Original size
+          data << [@original_size].pack("Q<")
+
+          # CRC (0 if not set)
+          data << [crc || 0].pack("V")
+
+          # Encrypted data
+          data << @encrypted_data
+
+          data
+        end
+
+        # Parse encrypted header from binary data
+        #
+        # @param data [String] Binary data
+        # @return [EncryptedHeader] Parsed header
+        # @raise [RuntimeError] if data is invalid
+        def self.from_binary(data)
+          raise Omnizip::InvalidArchiveError, "Invalid encrypted header: too short" if data.bytesize < 54
+
+          pos = 0
+
+          # Check marker
+          marker = data.getbyte(pos)
+          pos += 1
+          unless marker == PropertyId::ENCODED_HEADER
+            raise Omnizip::InvalidArchiveError, "Invalid encrypted header marker: expected #{PropertyId::ENCODED_HEADER}, got #{marker}"
+          end
+
+          # Read encrypted data size
+          encrypted_size = data[pos, 8].unpack1("Q<")
+          pos += 8
+
+          # Read salt
+          salt = data[pos, 16]
+          pos += 16
+
+          # Read IV
+          iv = data[pos, 16]
+          pos += 16
+
+          # Read original size
+          original_size = data[pos, 8].unpack1("Q<")
+          pos += 8
+
+          # Read CRC
+          crc = data[pos, 4].unpack1("V")
+          pos += 4
+
+          # Read encrypted data
+          encrypted_data = data[pos, encrypted_size]
+
+          new(
+            encrypted_data: encrypted_data,
+            salt: salt,
+            iv: iv,
+            original_size: original_size,
+            crc: crc.zero? ? nil : crc,
+          )
+        end
+
+        # Check if header is valid
+        #
+        # @return [Boolean] true if has all required fields
+        def valid?
+          !@encrypted_data.nil? &&
+            !@salt.nil? &&
+            !@iv.nil? &&
+            @original_size.positive? &&
+            @encrypted_data.bytesize.positive?
+        end
+
+        # Verify CRC if set
+        #
+        # @return [Boolean] true if CRC matches or not set
+        def verify_crc
+          return true if @crc.nil?
+
+          calc_crc = Omnizip::Checksums::Crc32.new
+          calc_crc.update(@encrypted_data)
+          calc_crc.value == @crc
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/file_collector.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Collects files and directories for archiving
+      # Handles file metadata, timestamps, and attributes
+      class FileCollector
+        attr_reader :entries
+
+        # Initialize collector
+        def initialize
+          @entries = []
+          @base_path = nil
+        end
+
+        # Add path (file or directory) to collection
+        #
+        # @param path [String] Path to file or directory
+        # @param archive_path [String, nil] Path in archive (nil = auto)
+        # @param recursive [Boolean] Recursively add directories
+        def add_path(path, archive_path: nil, recursive: true)
+          path = File.expand_path(path)
+          raise Errno::ENOENT, "Path not found: #{path}" unless File.exist?(path)
+
+          @base_path ||= File.dirname(path)
+
+          if File.directory?(path)
+            add_directory(path, archive_path, recursive)
+          else
+            add_file(path, archive_path)
+          end
+        end
+
+        # Add files matching glob pattern
+        #
+        # @param pattern [String] Glob pattern
+        # @param base_path [String, nil] Base path for relative names
+        def add_glob(pattern, base_path: nil)
+          @base_path ||= base_path || Dir.pwd
+
+          Dir.glob(pattern).each do |path|
+            add_path(path)
+          end
+        end
+
+        # Get collected file entries
+        #
+        # @return [Array<Models::FileEntry>] File entries
+        def collect_files
+          @entries.sort_by(&:name)
+        end
+
+        private
+
+        # Add single file
+        #
+        # @param file_path [String] Full path to file
+        # @param archive_path [String, nil] Path in archive
+        def add_file(file_path, archive_path)
+          archive_name = archive_path || relative_path(file_path)
+
+          entry = Models::FileEntry.new.tap do |e|
+            e.name = archive_name
+            e.size = File.size(file_path)
+            e.has_stream = e.size.positive?
+            e.is_dir = false
+            e.mtime = File.mtime(file_path)
+            e.attributes = file_attributes(file_path)
+            e.source_path = file_path
+          end
+
+          @entries << entry
+        end
+
+        # Add directory and optionally its contents
+        #
+        # @param dir_path [String] Directory path
+        # @param archive_path [String, nil] Path in archive
+        # @param recursive [Boolean] Add contents recursively
+        def add_directory(dir_path, archive_path, recursive)
+          archive_name = archive_path || relative_path(dir_path)
+          archive_name += "/" unless archive_name.end_with?("/")
+
+          # Add directory entry
+          entry = Models::FileEntry.new.tap do |e|
+            e.name = archive_name
+            e.size = 0
+            e.has_stream = false
+            e.is_dir = true
+            e.mtime = File.mtime(dir_path)
+            e.attributes = file_attributes(dir_path)
+          end
+
+          @entries << entry
+
+          return unless recursive
+
+          # Add contents
+          Dir.each_child(dir_path) do |child|
+            child_path = File.join(dir_path, child)
+            add_path(child_path, archive_path: nil, recursive: true)
+          end
+        end
+
+        # Get relative path for archive
+        #
+        # @param path [String] Full path
+        # @return [String] Relative path
+        def relative_path(path)
+          if @base_path && path.start_with?(@base_path)
+            path[@base_path.length..].sub(%r{^/}, "")
+          else
+            File.basename(path)
+          end
+        end
+
+        # Get file attributes (Unix permissions as Windows attributes)
+        #
+        # @param path [String] File path
+        # @return [Integer] Attribute flags
+        def file_attributes(path)
+          attrs = 0
+          stat = File.stat(path)
+
+          # Windows FILE_ATTRIBUTE_DIRECTORY = 0x10
+          attrs |= 0x10 if stat.directory?
+
+          # Windows FILE_ATTRIBUTE_ARCHIVE = 0x20
+          attrs |= 0x20 unless stat.directory?
+
+          # Convert Unix permissions to Windows read-only flag
+          # FILE_ATTRIBUTE_READONLY = 0x01
+          attrs |= 0x01 unless stat.writable?
+
+          attrs
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/header.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # .7z archive header parser
+      # Handles signature validation and start header
+      class Header
+        include Omnizip::Formats::SevenZip::Constants
+
+        attr_reader :major_version, :minor_version, :start_header_crc,
+                    :next_header_offset, :next_header_size, :next_header_crc
+
+        # Parse header from IO
+        #
+        # @param io [IO] Input stream
+        # @return [Header] Parsed header
+        # @raise [RuntimeError] if signature or CRC invalid
+        def self.read(io)
+          header = new
+          header.parse(io)
+          header
+        end
+
+        # Parse header data from IO stream
+        #
+        # @param io [IO] Input stream positioned at start
+        # @raise [RuntimeError] if signature or version invalid
+        def parse(io)
+          # Read complete start header (32 bytes)
+          header_data = io.read(START_HEADER_SIZE)
+          raise Omnizip::InvalidArchiveError, "Invalid .7z file: too short" if header_data.nil? ||
+            header_data.bytesize < START_HEADER_SIZE
+
+          # Validate signature
+          signature = header_data[0, SIGNATURE_SIZE]
+          unless signature == SIGNATURE
+            raise Omnizip::InvalidArchiveError, "Invalid .7z signature: expected #{SIGNATURE.inspect}, " \
+                                                "got #{signature.inspect}"
+          end
+
+          # Parse version
+          @major_version = header_data.getbyte(6)
+          @minor_version = header_data.getbyte(7)
+
+          unless @major_version == MAJOR_VERSION
+            raise Omnizip::UnsupportedFormatError, "Unsupported .7z version: #{@major_version}.#{@minor_version}"
+          end
+
+          # Parse start header CRC (bytes 8-11)
+          @start_header_crc = header_data[8, 4].unpack1("V")
+
+          # Parse next header info (bytes 12-31, 20 bytes total)
+          next_header_data = header_data[12, 20]
+
+          # NOTE: CRC validation temporarily disabled for Phase 2
+          # Will be refined in Phase 3 with proper CRC32 initialization
+          # calculated_crc = calculate_crc32(next_header_data)
+          # unless calculated_crc == @start_header_crc
+          #   warn "CRC mismatch (non-fatal): expected " \
+          #        "#{@start_header_crc.to_s(16)}, " \
+          #        "got #{calculated_crc.to_s(16)}"
+          # end
+
+          # Parse next header offset and size
+          @next_header_offset = next_header_data[0, 8].unpack1("Q<")
+          @next_header_size = next_header_data[8, 8].unpack1("Q<")
+          @next_header_crc = next_header_data[16, 4].unpack1("V")
+
+          self
+        end
+
+        # Get position after start header
+        #
+        # @return [Integer] Byte position
+        def start_pos_after_header
+          START_HEADER_SIZE
+        end
+
+        # Check if header is valid
+        #
+        # @return [Boolean] true if valid
+        def valid?
+          !@next_header_offset.nil? && !@next_header_size.nil?
+        end
+
+        private
+
+        # Calculate CRC32 checksum
+        # Note: Needs refinement for .7z CRC compatibility
+        #
+        # @param data [String] Binary data
+        # @return [Integer] CRC32 value
+        def calculate_crc32(data)
+          crc = Omnizip::Checksums::Crc32.new
+          crc.update(data)
+          crc.value
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/header_encryptor.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # 7z header encryption using AES-256
+      # Encrypts archive headers to hide filenames and structure
+      class HeaderEncryptor
+        include Omnizip::Formats::SevenZip::Constants
+
+        # AES-256 parameters
+        AES_KEY_SIZE = 32  # 256 bits
+        AES_IV_SIZE = 16   # 128 bits
+        SALT_SIZE = 16     # 128 bits
+
+        # PBKDF2 parameters
+        PBKDF2_ITERATIONS = 262_144 # 256K iterations for strong key derivation
+
+        attr_reader :password, :salt, :iv
+
+        # Initialize encryptor with password
+        #
+        # @param password [String] Encryption password
+        def initialize(password)
+          @password = password
+          @salt = nil
+          @iv = nil
+        end
+
+        # Encrypt header data
+        #
+        # @param header_data [String] Unencrypted header bytes
+        # @return [Hash] Encrypted data with metadata
+        #   - :data [String] Encrypted bytes
+        #   - :salt [String] Salt used for key derivation
+        #   - :iv [String] Initialization vector
+        #   - :size [Integer] Original size before encryption
+        def encrypt(header_data)
+          # Generate random salt and IV
+          @salt = OpenSSL::Random.random_bytes(SALT_SIZE)
+          @iv = OpenSSL::Random.random_bytes(AES_IV_SIZE)
+
+          # Derive encryption key from password
+          key = derive_key(@password, @salt)
+
+          # Encrypt data
+          cipher = OpenSSL::Cipher.new("AES-256-CBC")
+          cipher.encrypt
+          cipher.key = key
+          cipher.iv = @iv
+
+          encrypted = cipher.update(header_data) + cipher.final
+
+          {
+            data: encrypted,
+            salt: @salt,
+            iv: @iv,
+            size: header_data.bytesize,
+          }
+        end
+
+        # Decrypt header data
+        #
+        # @param encrypted_data [String] Encrypted bytes
+        # @param salt [String] Salt used during encryption
+        # @param iv [String] Initialization vector
+        # @return [String] Decrypted header bytes
+        # @raise [RuntimeError] if password is incorrect
+        def decrypt(encrypted_data, salt, iv)
+          # Derive decryption key from password
+          key = derive_key(@password, salt)
+
+          # Decrypt data
+          decipher = OpenSSL::Cipher.new("AES-256-CBC")
+          decipher.decrypt
+          decipher.key = key
+          decipher.iv = iv
+          # Ensure padding validation is enabled (default, but explicit)
+          decipher.padding = 1
+
+          begin
+            decipher.update(encrypted_data) + decipher.final
+          rescue OpenSSL::Cipher::CipherError => e
+            raise Omnizip::PasswordError, "Failed to decrypt header: incorrect password or corrupted data (#{e.message})"
+          rescue StandardError => e
+            raise Omnizip::PasswordError, "Failed to decrypt header: incorrect password or corrupted data (#{e.message})"
+          end
+        end
+
+        # Derive encryption key from password using PBKDF2
+        #
+        # @param password [String] User password
+        # @param salt [String] Random salt
+        # @return [String] Derived key
+        def derive_key(password, salt)
+          OpenSSL::PKCS5.pbkdf2_hmac(
+            password,
+            salt,
+            PBKDF2_ITERATIONS,
+            AES_KEY_SIZE,
+            OpenSSL::Digest.new("SHA256"),
+          )
+        end
+
+        # Verify password against encrypted header
+        #
+        # @param encrypted_data [String] Encrypted header
+        # @param salt [String] Salt used
+        # @param iv [String] IV used
+        # @return [Boolean] true if password can decrypt
+        def verify_password(encrypted_data, salt, iv)
+          decrypt(encrypted_data, salt, iv)
+          true
+        rescue StandardError
+          false
+        end
+
+        # Calculate CRC of header data
+        #
+        # @param data [String] Header data
+        # @return [Integer] CRC32 value
+        def calculate_crc(data)
+          crc = Omnizip::Checksums::Crc32.new
+          crc.update(data)
+          crc.value
+        end
+      end
+    end
+  end
+end