rufio 1.1.0 → 1.3.0

data/lib/rufio/zip_extractor.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'zlib'
+require_relative 'zip_archive'
+require_relative 'native_zip'
+
+module Rufio
+  # ZIPアーカイブの安全な展開（Pure Ruby 実装。ネイティブ実装の互換基準でもある）
+  #
+  # 書き込み前に全エントリを検証し、1件でも危険なエントリがあれば何も書かずに中止する。
+  # - Zip Slip: 絶対パス・ドライブレター・".." を含むエントリ、展開先外を指すエントリを拒否
+  # - シンボリックリンクのエントリは展開しない（展開先の既存シンボリックリンクも辿らない）
+  # - ZIP 爆弾: 展開後合計サイズ・エントリ数・圧縮率の上限、データ範囲が重なるエントリの拒否、
+  #   宣言サイズを超えて伸長されたら中止
+  # - CRC-32 不一致のファイルは残さない（一時ファイルに書いてから rename）
+  # - 既存ファイルは overwrite: true のときだけ上書きする
+  class ZipExtractor
+    class Error < StandardError; end
+    class UnsafeEntryError < Error; end
+    class LimitExceededError < Error; end
+    class ConflictError < Error; end
+    class CorruptEntryError < Error; end
+    class CancelledError < Error; end
+
+    DEFAULT_MAX_TOTAL_SIZE = 16 * 1024 * 1024 * 1024 # 16 GiB
+    DEFAULT_MAX_ENTRIES = 100_000
+    DEFAULT_MAX_RATIO = 1000
+    # 圧縮率の上限はこのサイズを超えるエントリにだけ適用する（小さな高圧縮ファイルは正常）
+    RATIO_CHECK_MIN_SIZE = 1024 * 1024
+
+    LOCAL_HEADER_SIGNATURE = 0x04034b50
+    LOCAL_HEADER_SIZE = 30
+    CHUNK_SIZE = 64 * 1024
+    SUPPORTED_METHODS = [0, 8].freeze
+
+    Result = Struct.new(:extracted, :skipped, :bytes_written, keyword_init: true)
+
+    # @param zip_path [String]
+    # @param destination [String] 展開先ディレクトリ（なければ作成する）
+    # @param progress [#call, nil] (書き込み済みバイト数, 合計バイト数) を受け取る
+    # @param cancelled [#call, nil] true を返したら CancelledError で中止する
+    # @param native [Boolean] Zig 実装でデータを並列に伸長する（検証は常に Ruby 側で行う）
+    def initialize(zip_path, destination, overwrite: false,
+                   max_total_size: DEFAULT_MAX_TOTAL_SIZE, max_entries: DEFAULT_MAX_ENTRIES,
+                   max_ratio: DEFAULT_MAX_RATIO, progress: nil, cancelled: nil, native: NativeZip.available?)
+      @zip_path = zip_path
+      @destination = File.expand_path(destination)
+      @overwrite = overwrite
+      @max_total_size = max_total_size
+      @max_entries = max_entries
+      @max_ratio = max_ratio
+      @progress = progress
+      @cancelled = cancelled
+      @native = native
+    end
+
+    def extract
+      listing = ZipArchive.list(@zip_path)
+      raise LimitExceededError, "Too many entries (#{listing.total_entries} > #{@max_entries})" if listing.total_entries > @max_entries
+
+      File.open(@zip_path, 'rb') do |io|
+        plan, skipped = build_plan(io, listing)
+        FileUtils.mkdir_p(@destination)
+        root = File.realpath(@destination)
+        total = plan.sum { |item| item[:entry].size }
+
+        # 書き込み先をすべて確定させてからデータを書く
+        plan.each do |item|
+          check_cancel!
+          item[:target] = safe_target(root, item[:relative])
+          make_directory(root, item[:entry].directory? ? item[:target] : File.dirname(item[:target]))
+        end
+
+        files = plan.reject { |item| item[:entry].directory? }
+        written = if @native && !files.empty?
+                    write_files_native(files, total)
+                  else
+                    files.reduce(0) do |sum, item|
+                      check_cancel!
+                      write_file(io, item, sum, total)
+                    end
+                  end
+        apply_directory_times(root, plan)
+
+        Result.new(extracted: plan.map { |item| item[:relative] }, skipped: skipped, bytes_written: written)
+      end
+    end
+
+    # 展開先からの相対パスに正規化する。危険な名前は UnsafeEntryError
+    def self.normalize_entry_name(name)
+      raise UnsafeEntryError, 'Entry name is empty' if name.nil? || name.empty?
+      raise UnsafeEntryError, "Entry name contains NUL: #{name.inspect}" if name.include?("\0")
+
+      path = name.tr('\\', '/')
+      raise UnsafeEntryError, "Absolute path entry: #{name}" if path.start_with?('/') || path.match?(%r{\A[A-Za-z]:})
+
+      parts = path.split('/').reject { |part| part.empty? || part == '.' }
+      raise UnsafeEntryError, "Parent directory reference: #{name}" if parts.include?('..')
+      raise UnsafeEntryError, "Entry name is empty: #{name}" if parts.empty?
+      # Windows では ':' が代替データストリームやドライブ指定になる
+      raise UnsafeEntryError, "Entry name contains ':': #{name}" if Gem.win_platform? && parts.any? { |part| part.include?(':') }
+
+      parts.join('/')
+    end
+
+    private
+
+    # 書き込み前に全エントリを検証する
+    def build_plan(io, listing)
+      file_size = io.size
+      seen = {}
+      skipped = []
+      plan = []
+      total = 0
+
+      ranges = listing.entries.map do |entry|
+        start = data_start(io, entry, file_size)
+        finish = start + entry.compressed_size
+        raise CorruptEntryError, "Entry data is out of range: #{entry.name}" if finish > listing.central_directory_offset
+
+        [entry.local_header_offset, finish, entry, start]
+      end
+      check_overlaps(ranges)
+
+      ranges.each do |_header, _finish, entry, start|
+        relative = self.class.normalize_entry_name(entry.name)
+        if (reason = skip_reason(entry))
+          skipped << { name: entry.name, reason: reason }
+          next
+        end
+
+        raise UnsafeEntryError, "Duplicate entry: #{entry.name}" if seen[relative] && !entry.directory?
+
+        seen[relative] = true
+        check_limits(entry)
+        total += entry.size
+        raise LimitExceededError, "Total size exceeds limit (#{@max_total_size} bytes)" if total > @max_total_size
+
+        check_conflict(relative, entry)
+        plan << { entry: entry, relative: relative, data_offset: start }
+      end
+
+      [plan, skipped]
+    end
+
+    def skip_reason(entry)
+      return 'symlink' if entry.symlink?
+      return 'encrypted' if entry.encrypted?
+      return "unsupported method (#{ZipArchive.method_name(entry.method)})" unless entry.directory? || SUPPORTED_METHODS.include?(entry.method)
+
+      nil
+    end
+
+    def data_start(io, entry, file_size)
+      offset = entry.local_header_offset
+      raise CorruptEntryError, "Local header is out of range: #{entry.name}" if offset + LOCAL_HEADER_SIZE > file_size
+
+      io.seek(offset)
+      sig, *, name_length, extra_length = io.read(LOCAL_HEADER_SIZE).unpack('VvvvvvVVVvv')
+      raise CorruptEntryError, "Invalid local header: #{entry.name}" unless sig == LOCAL_HEADER_SIGNATURE
+
+      offset + LOCAL_HEADER_SIZE + name_length + extra_length
+    end
+
+    # 同じデータ範囲を複数エントリで共有する ZIP 爆弾（重複参照型）を拒否する
+    def check_overlaps(ranges)
+      ranges.sort_by(&:first).each_cons(2) do |(_, prev_finish, prev, _), (next_start, _, entry, _)|
+        raise UnsafeEntryError, "Overlapping entries: #{prev.name}, #{entry.name}" if next_start < prev_finish
+      end
+    end
+
+    def check_limits(entry)
+      return if entry.directory?
+      return if entry.size <= RATIO_CHECK_MIN_SIZE
+
+      if entry.compressed_size.zero? || entry.size / entry.compressed_size > @max_ratio
+        raise LimitExceededError, "Compression ratio exceeds limit (#{@max_ratio}:1): #{entry.name}"
+      end
+    end
+
+    def check_conflict(relative, entry)
+      target = File.join(@destination, relative)
+      return unless File.exist?(target) || File.symlink?(target)
+      return if entry.directory? && File.directory?(target) && !File.symlink?(target)
+      return if @overwrite && File.file?(target) && !File.symlink?(target)
+
+      raise ConflictError, "Already exists: #{relative}"
+    end
+
+    # 展開先の既存シンボリックリンクを辿って外に出ないことを確認する
+    def safe_target(root, relative)
+      target = File.join(root, relative)
+      current = root
+      relative.split('/')[0...-1].each do |part|
+        current = File.join(current, part)
+        next if verified_dirs.include?(current)
+        raise UnsafeEntryError, "Path goes through a symlink: #{relative}" if File.symlink?(current)
+      end
+      raise UnsafeEntryError, "Target is a symlink: #{relative}" if File.symlink?(target)
+
+      target
+    end
+
+    # 作成・検証済みのディレクトリ（同じディレクトリへの多数のファイルで検証を繰り返さない）
+    def verified_dirs
+      @verified_dirs ||= {}
+    end
+
+    def make_directory(root, path)
+      return if verified_dirs.include?(path)
+
+      FileUtils.mkdir_p(path)
+      real = File.realpath(path)
+      raise UnsafeEntryError, "Directory escapes destination: #{path}" unless real == root || real.start_with?(root.end_with?('/') ? root : "#{root}/")
+
+      # safe_target で途中にシンボリックリンクがないことを確認済みなので、祖先も検証済みとして扱う
+      current = path
+      until current == root || current.length <= root.length || verified_dirs.include?(current)
+        verified_dirs[current] = true
+        current = File.dirname(current)
+      end
+    end
+
+    def write_file(io, item, written, total)
+      entry = item[:entry]
+      temp = temp_path(item[:target])
+      crc = 0
+      size = 0
+
+      File.open(temp, File::WRONLY | File::CREAT | File::EXCL | File::BINARY, 0o600) do |out|
+        each_chunk(io, item) do |chunk|
+          size += chunk.bytesize
+          raise CorruptEntryError, "Entry is larger than declared: #{entry.name}" if size > entry.size
+
+          crc = Zlib.crc32(chunk, crc)
+          out.write(chunk)
+          written += chunk.bytesize
+          @progress&.call(written, total)
+          check_cancel!
+        end
+      end
+
+      raise CorruptEntryError, "Entry is smaller than declared: #{entry.name}" if size != entry.size
+      raise CorruptEntryError, "CRC-32 mismatch: #{entry.name}" if crc != entry.crc32
+
+      finish_file(temp, item)
+      written
+    ensure
+      File.unlink(temp) if temp && File.exist?(temp)
+    end
+
+    # Zig 実装で全ファイルを並列に一時ファイルへ伸長し、すべて検証が通ってから rename する
+    def write_files_native(files, total)
+      temps = files.map { |item| temp_path(item[:target]) }
+      tasks = files.each_with_index.map do |item, index|
+        entry = item[:entry]
+        { data_offset: item[:data_offset], compressed_size: entry.compressed_size, size: entry.size,
+          crc32: entry.crc32, method: entry.method, output: temps[index] }
+      end
+
+      job = NativeZip.extract(@zip_path, tasks)
+      begin
+        state = job.wait(progress: @progress && ->(done, _) { @progress.call(done, total) }, cancelled: @cancelled)
+        raise CancelledError, 'Extraction cancelled' if state == NativeZip::STATE_CANCELLED
+
+        files.each_with_index { |item, index| check_native_status(job.status(index), item[:entry]) }
+        files.each_with_index { |item, index| finish_file(temps[index], item) }
+      ensure
+        job.close
+        temps.each { |temp| File.unlink(temp) if File.exist?(temp) }
+      end
+      total
+    end
+
+    def check_native_status(status, entry)
+      case status
+      when NativeZip::STATUS_OK then nil
+      when NativeZip::STATUS_CRC_MISMATCH then raise CorruptEntryError, "CRC-32 mismatch: #{entry.name}"
+      when NativeZip::STATUS_TOO_LARGE then raise CorruptEntryError, "Entry is larger than declared: #{entry.name}"
+      when NativeZip::STATUS_SIZE_MISMATCH then raise CorruptEntryError, "Entry is smaller than declared: #{entry.name}"
+      when NativeZip::STATUS_CORRUPT then raise CorruptEntryError, "Invalid compressed data: #{entry.name}"
+      when NativeZip::STATUS_CANCELLED then raise CancelledError, 'Extraction cancelled'
+      else raise Error, "Failed to write #{entry.name}"
+      end
+    end
+
+    def temp_path(target)
+      "#{target}.rufio-#{Process.pid}-#{rand(1 << 32).to_s(16)}.tmp"
+    end
+
+    def finish_file(temp, item)
+      entry = item[:entry]
+      apply_mode(temp, entry)
+      File.rename(temp, item[:target])
+      File.utime(entry.mtime, entry.mtime, item[:target]) if entry.mtime
+    end
+
+    def each_chunk(io, item)
+      entry = item[:entry]
+      io.seek(item[:data_offset])
+      remaining = entry.compressed_size
+      inflater = entry.method == 8 ? Zlib::Inflate.new(-Zlib::MAX_WBITS) : nil
+
+      while remaining.positive?
+        data = io.read([remaining, CHUNK_SIZE].min)
+        raise CorruptEntryError, "Unexpected end of data: #{entry.name}" if data.nil? || data.empty?
+
+        remaining -= data.bytesize
+        if inflater
+          # 伸長結果が宣言サイズを大きく超えないよう、小分けに伸長する
+          inflater.inflate(data) { |chunk| yield chunk }
+        else
+          yield data
+        end
+      end
+      inflater&.finish&.then { |rest| yield rest unless rest.empty? }
+    rescue Zlib::Error => e
+      raise CorruptEntryError, "Invalid compressed data: #{entry.name} (#{e.message})"
+    ensure
+      inflater&.close
+    end
+
+    # 実行権限だけを引き継ぐ（setuid / setgid / sticky や他者書き込み権限は付けない）
+    def apply_mode(path, entry)
+      return if Gem.win_platform?
+
+      @umask ||= File.umask
+      mode = entry.unix_mode
+      File.chmod(mode && (mode & 0o111).nonzero? ? 0o777 & ~@umask & ~0o022 : 0o666 & ~@umask, path)
+    end
+
+    def apply_directory_times(root, plan)
+      plan.reverse_each do |item|
+        entry = item[:entry]
+        next unless entry.directory? && entry.mtime
+
+        File.utime(entry.mtime, entry.mtime, File.join(root, item[:relative]))
+      end
+    end
+
+    def check_cancel!
+      raise CancelledError, 'Extraction cancelled' if @cancelled&.call
+    end
+  end
+end

data/lib/rufio/zip_writer.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'zlib'
+require_relative 'zip_archive'
+require_relative 'native_zip'
+
+module Rufio
+  # ZIPアーカイブの作成（Pure Ruby 実装。ネイティブ実装の互換基準でもある）
+  #
+  # - ファイル名は UTF-8（汎用フラグ bit 11）で格納する
+  # - Deflate で縮まないファイルは Stored で格納し直す
+  # - 4GiB 超のファイル・オフセット、65535 件超のエントリでは ZIP64 を使う
+  # - シンボリックリンクは辿らずにスキップする
+  # - 一時ファイルに書いてから rename するので、失敗・中止時に壊れたアーカイブを残さない
+  class ZipWriter
+    class Error < StandardError; end
+    class ConflictError < Error; end
+    class CancelledError < Error; end
+
+    LOCAL_HEADER_SIGNATURE = 0x04034b50
+    CHUNK_SIZE = 64 * 1024
+    MAX32 = 0xFFFFFFFF
+    MAX16 = 0xFFFF
+    # Deflate で僅かに膨らんでも 32bit に収まるよう、このサイズ以上は最初から ZIP64 拡張を付ける
+    ZIP64_LOCAL_THRESHOLD = 0xFFFF0000
+    VERSION_DEFAULT = 20
+    VERSION_ZIP64 = 45
+    VERSION_MADE_BY = (ZipArchive::HOST_UNIX << 8) | 63
+    METHOD_STORED = 0
+    METHOD_DEFLATE = 8
+    # これ未満のファイルは Zig に渡さずその場で圧縮する（一時ファイルの作成・コピーの方が高くつく）
+    NATIVE_MIN_SIZE = 1024 * 1024
+
+    Result = Struct.new(:added, :skipped, :bytes_read, keyword_init: true)
+    Item = Struct.new(:path, :name, :directory, :size, :mtime, :mode, keyword_init: true)
+
+    # @param zip_path [String] 作成するZIPファイル
+    # @param base_dir [String] アーカイブ内パスの基準ディレクトリ
+    # @param paths [Array<String>] base_dir からの相対パス（ディレクトリは再帰的に追加）
+    # @param native [Boolean] Zig 実装でファイルを並列に圧縮してから順に格納する
+    def initialize(zip_path, base_dir, paths, level: Zlib::DEFAULT_COMPRESSION, overwrite: false,
+                   progress: nil, cancelled: nil, native: NativeZip.available?)
+      @zip_path = File.expand_path(zip_path)
+      @base_dir = File.expand_path(base_dir)
+      @paths = paths
+      @level = level
+      @overwrite = overwrite
+      @progress = progress
+      @cancelled = cancelled
+      @native = native
+    end
+
+    def write
+      raise ConflictError, "Already exists: #{@zip_path}" if File.exist?(@zip_path) && !@overwrite
+
+      items, skipped = collect_items
+      total = items.sum(&:size)
+      temp = "#{@zip_path}.rufio-#{Process.pid}-#{rand(1 << 32).to_s(16)}.tmp"
+      bytes_read = 0
+      prepared = {}
+      native_items = @native ? items.select { |item| !item.directory && item.size >= NATIVE_MIN_SIZE } : []
+      unless native_items.empty?
+        parts_dir = "#{temp}.parts"
+        Dir.mkdir(parts_dir, 0o700)
+        prepared = deflate_natively(native_items, parts_dir, total)
+        bytes_read = native_items.sum(&:size)
+      end
+
+      File.open(temp, File::RDWR | File::CREAT | File::EXCL | File::BINARY, 0o644) do |out|
+        centrals = items.map do |item|
+          check_cancel!
+          record = write_entry(out, item, prepared[item]) do |count|
+            bytes_read += count
+            @progress&.call(bytes_read, total)
+            check_cancel!
+          end
+          central_header(item, record)
+        end
+        write_end_records(out, centrals, items.length)
+      end
+      File.rename(temp, @zip_path)
+
+      Result.new(added: items.map(&:name), skipped: skipped, bytes_read: bytes_read)
+    ensure
+      File.unlink(temp) if temp && File.exist?(temp)
+      FileUtils.rm_rf(parts_dir) if parts_dir
+    end
+
+    private
+
+    def collect_items
+      items = []
+      skipped = []
+      @paths.each do |relative|
+        path = File.expand_path(relative, @base_dir)
+        raise Error, "Path is outside the base directory: #{relative}" unless path.start_with?(base_prefix)
+
+        collect_path(path, items, skipped)
+      end
+      [items.uniq(&:name), skipped]
+    end
+
+    def base_prefix
+      @base_prefix ||= @base_dir.end_with?('/') ? @base_dir : "#{@base_dir}/"
+    end
+
+    def collect_path(path, items, skipped)
+      name = path.delete_prefix(base_prefix)
+      stat = File.lstat(path)
+
+      if stat.symlink?
+        skipped << { name: name, reason: 'symlink' }
+      elsif File.identical?(path, @zip_path)
+        skipped << { name: name, reason: 'output archive' }
+      elsif stat.directory?
+        items << Item.new(path: path, name: "#{name}/", directory: true, size: 0, mtime: stat.mtime, mode: stat.mode)
+        Dir.children(path).sort.each { |child| collect_path(File.join(path, child), items, skipped) }
+      elsif stat.file?
+        items << Item.new(path: path, name: name, directory: false, size: stat.size, mtime: stat.mtime, mode: stat.mode)
+      else
+        skipped << { name: name, reason: 'special file' }
+      end
+    end
+
+    # Zig 実装で各ファイルを raw DEFLATE で parts_dir に並列に圧縮する
+    # @return [Hash{Item => Hash}] crc / compressed / part
+    def deflate_natively(files, parts_dir, total)
+      tasks = files.each_with_index.map { |item, index| { source: item.path, output: File.join(parts_dir, index.to_s) } }
+      job = NativeZip.deflate(tasks, level: @level)
+      begin
+        state = job.wait(progress: @progress && ->(done, _) { @progress.call(done, total) }, cancelled: @cancelled)
+        raise CancelledError, 'Archive creation cancelled' if state == NativeZip::STATE_CANCELLED
+
+        files.each_with_index.to_h do |item, index|
+          status, crc, compressed, size = job.result(index)
+          raise CancelledError, 'Archive creation cancelled' if status == NativeZip::STATUS_CANCELLED
+          raise Error, "Failed to compress #{item.name}" unless status == NativeZip::STATUS_OK
+          raise Error, "File changed while compressing: #{item.name}" unless size == item.size
+
+          [item, { crc: crc, compressed: compressed, part: tasks[index][:output] }]
+        end
+      ensure
+        job.close
+      end
+    end
+
+    def write_entry(out, item, prepared = nil)
+      offset = out.pos
+      name = item.name.encode(Encoding::UTF_8).b
+      zip64_local = item.size >= ZIP64_LOCAL_THRESHOLD
+      dos_time, dos_date = dos_datetime(item.mtime)
+      flags = ZipArchive::FLAG_UTF8
+
+      method = item.directory || item.size.zero? ? METHOD_STORED : METHOD_DEFLATE
+      out.write(local_header(name, flags, method, dos_time, dos_date, zip64_local))
+      data_offset = out.pos
+
+      crc, compressed = if prepared
+                          copy_prepared(out, item, prepared)
+                        elsif item.directory
+                          [0, 0]
+                        else
+                          write_data(out, item, method) { |n| yield n }
+                        end
+      if method == METHOD_DEFLATE && compressed >= item.size
+        # 縮まなかったので Stored で書き直す（ヘッダは固定長なので位置は変わらない）
+        method = METHOD_STORED
+        out.seek(data_offset)
+        out.truncate(data_offset)
+        crc, compressed = write_data(out, item, method) { |_| nil }
+      end
+      raise Error, "File too large for this entry: #{item.name}" if !zip64_local && compressed > MAX32
+
+      # 圧縮後のサイズと CRC を入れたローカルヘッダで書き戻す
+      finish = out.pos
+      out.seek(offset)
+      out.write(local_header(name, flags, method, dos_time, dos_date, zip64_local,
+                             crc: crc, compressed: compressed, size: item.size))
+      out.seek(finish)
+
+      { offset: offset, crc: crc, compressed: compressed, method: method, flags: flags,
+        dos_time: dos_time, dos_date: dos_date, name: name }
+    end
+
+    def copy_prepared(out, item, prepared)
+      copied = IO.copy_stream(prepared[:part], out)
+      raise Error, "Compressed data is incomplete: #{item.name}" unless copied == prepared[:compressed]
+
+      [prepared[:crc], prepared[:compressed]]
+    end
+
+    def local_header(name, flags, method, dos_time, dos_date, zip64, crc: 0, compressed: 0, size: 0)
+      extra = zip64 ? [ZipArchive::ZIP64_EXTRA_ID, 16, size, compressed].pack('vvQ<Q<') : ''.b
+      version = zip64 ? VERSION_ZIP64 : VERSION_DEFAULT
+      sizes = zip64 ? [MAX32, MAX32] : [compressed, size]
+      [LOCAL_HEADER_SIGNATURE, version, flags, method, dos_time, dos_date, crc, *sizes,
+       name.bytesize, extra.bytesize].pack('VvvvvvVVVvv') + name + extra
+    end
+
+    def write_data(out, item, method)
+      crc = 0
+      compressed = 0
+      deflater = method == METHOD_DEFLATE ? Zlib::Deflate.new(@level, -Zlib::MAX_WBITS) : nil
+
+      File.open(item.path, 'rb') do |file|
+        while (chunk = file.read(CHUNK_SIZE))
+          crc = Zlib.crc32(chunk, crc)
+          data = deflater ? deflater.deflate(chunk) : chunk
+          compressed += out.write(data)
+          yield chunk.bytesize
+        end
+      end
+      compressed += out.write(deflater.finish) if deflater
+      [crc, compressed]
+    ensure
+      deflater&.close
+    end
+
+    def central_header(item, record)
+      zip64_values = []
+      size = item.size
+      compressed = record[:compressed]
+      offset = record[:offset]
+      zip64_values << size if size >= MAX32
+      zip64_values << compressed if compressed >= MAX32
+      zip64_values << offset if offset >= MAX32
+      extra = zip64_values.empty? ? ''.b : [ZipArchive::ZIP64_EXTRA_ID, zip64_values.size * 8, *zip64_values].pack("vvQ<#{zip64_values.size}")
+      version = zip64_values.empty? ? VERSION_DEFAULT : VERSION_ZIP64
+      type = item.directory ? ZipArchive::S_IFDIR : ZipArchive::S_IFREG
+      external = ((type | (item.mode & 0o777)) << 16) | (item.directory ? 0x10 : 0)
+
+      [ZipArchive::CENTRAL_HEADER_SIGNATURE, VERSION_MADE_BY, version, record[:flags], record[:method],
+       record[:dos_time], record[:dos_date], record[:crc], [compressed, MAX32].min, [size, MAX32].min,
+       record[:name].bytesize, extra.bytesize, 0, 0, 0, external, [offset, MAX32].min]
+        .pack('VvvvvvvVVVvvvvvVV') + record[:name] + extra
+    end
+
+    def write_end_records(out, centrals, count)
+      cd_offset = out.pos
+      centrals.each { |header| out.write(header) }
+      cd_size = out.pos - cd_offset
+
+      if count >= MAX16 || cd_size >= MAX32 || cd_offset >= MAX32
+        zip64_offset = out.pos
+        out.write([ZipArchive::ZIP64_EOCD_SIGNATURE, 44, VERSION_MADE_BY, VERSION_ZIP64, 0, 0,
+                   count, count, cd_size, cd_offset].pack('VQ<vvVVQ<Q<Q<Q<'))
+        out.write([ZipArchive::ZIP64_LOCATOR_SIGNATURE, 0, zip64_offset, 1].pack('VVQ<V'))
+      end
+
+      out.write([ZipArchive::EOCD_SIGNATURE, 0, 0, [count, MAX16].min, [count, MAX16].min,
+                 [cd_size, MAX32].min, [cd_offset, MAX32].min, 0].pack('VvvvvVVv'))
+    end
+
+    # DOS 日時は 1980〜2107 年のみ表現できる
+    def dos_datetime(time)
+      time = time.localtime
+      return [0, (1 << 5) | 1] if time.year < 1980
+
+      time = Time.new(2107, 12, 31, 23, 59, 58) if time.year > 2107
+      [(time.hour << 11) | (time.min << 5) | (time.sec / 2), ((time.year - 1980) << 9) | (time.month << 5) | time.day]
+    end
+
+    def check_cancel!
+      raise CancelledError, 'Archive creation cancelled' if @cancelled&.call
+    end
+  end
+end

data/lib/rufio/zoxide_integration.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require_relative 'dialog_support'
+
 require 'shellwords'
 
 module Rufio
   # Integrates with zoxide for directory history navigation
   class ZoxideIntegration
+    include DialogSupport
+
     # Dialog size constants
     DIALOG_WIDTH = 45
     DIALOG_BORDER_HEIGHT = 4
@@ -88,48 +92,6 @@ module Rufio
 
     private
 
-    # オーバーレイダイアログを表示してキー入力を待つヘルパーメソッド
-    def show_overlay_dialog(title, content_lines, options = {}, &block)
-      # terminal_ui が利用可能で、screen と renderer が存在する場合のみオーバーレイを使用
-      use_overlay = @terminal_ui &&
-                    @terminal_ui.respond_to?(:screen) &&
-                    @terminal_ui.respond_to?(:renderer) &&
-                    @terminal_ui.screen &&
-                    @terminal_ui.renderer
-
-      if use_overlay
-        # オーバーレイを使用
-        @terminal_ui.show_overlay_dialog(title, content_lines, options, &block)
-      else
-        # フォールバック: 従来の方法
-        width = options[:width]
-        height = options[:height]
-
-        unless width && height
-          width, height = @dialog_renderer.calculate_dimensions(content_lines, {
-            title: title,
-            min_width: options[:min_width] || 40,
-            max_width: options[:max_width] || 80
-          })
-        end
-
-        x, y = @dialog_renderer.calculate_center(width, height)
-
-        @dialog_renderer.draw_floating_window(x, y, width, height, title, content_lines, {
-          border_color: options[:border_color] || "\e[37m",
-          title_color: options[:title_color] || "\e[1;33m",
-          content_color: options[:content_color] || "\e[37m"
-        })
-
-        key = block_given? ? yield : STDIN.getch
-
-        @dialog_renderer.clear_area(x, y, width, height)
-        @terminal_ui&.refresh_display
-
-        key
-      end
-    end
-
     # Show message when no history is available
     def show_no_history_message
       return unless @dialog_renderer
@@ -197,7 +159,7 @@ module Rufio
         input_buffer = ''
 
         loop do
-          char = STDIN.getch
+          char = KeyInput.getch
 
           case char
           when "\e", "\x03" # ESC, Ctrl+C