vanken 0.1.0 → 0.2.0

data/lib/vanken/config/analysis_settings.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "yaml_file"
+
+module Vanken
+  module Config
+    class AnalysisSettings
+      def initialize(directory: Paths.config) = (@directory = directory)
+
+      def decode_as
+        value = YamlFile.read(File.join(@directory, "decode_as.yml"), default: {"rules" => []}).fetch("rules", [])
+        validate_rules(value)
+        value
+      end
+
+      def decode_as=(rules)
+        validate_rules(rules)
+        YamlFile.write(File.join(@directory, "decode_as.yml"), "rules" => rules)
+      end
+
+      def plugin_entries
+        entries = YamlFile.read(File.join(@directory, "plugins.yml"), default: {"files" => []}).fetch("files", [])
+        raise ConfigError, "invalid plugin list" unless entries.is_a?(Array) && entries.all? do |entry|
+          entry.is_a?(Hash) && entry["path"].is_a?(String) && !entry["path"].include?("\0") &&
+            [true, false].include?(entry["trusted"]) && [true, false].include?(entry["enabled"])
+        end
+        entries
+      end
+      def plugins = plugin_entries.select { |entry| entry["enabled"] && entry["trusted"] }.map { |entry| entry["path"] }
+      def untrusted_plugins = plugin_entries.select { |entry| entry["enabled"] && !entry["trusted"] }.map { |entry| entry["path"] }
+
+      def register_plugin(path)
+        raise ConfigError, "invalid plugin path" unless path.is_a?(String) && !path.include?("\0") && File.file?(path)
+        absolute = File.expand_path(path)
+        entries = plugin_entries.reject { |entry| entry["path"] == absolute }
+        entries << {"path" => absolute, "enabled" => true, "trusted" => false}
+        save_plugins(entries)
+      end
+
+      def remove_plugin(path) = save_plugins(plugin_entries.reject { |entry| entry["path"] == File.expand_path(path) })
+
+      def trust_plugins(paths)
+        entries = plugin_entries
+        raise ConfigError, "plugin is not registered" unless paths.all? { |path| entries.any? { |entry| entry["path"] == path } }
+        entries.each { |entry| entry["trusted"] = true if paths.include?(entry["path"]) }
+        save_plugins(entries)
+      end
+
+      private
+
+      def save_plugins(entries) = YamlFile.write(File.join(@directory, "plugins.yml"), "files" => entries)
+      def validate_rules(rules)
+        valid = rules.is_a?(Array) && rules.all? { |rule| rule.is_a?(String) && rule.match?(/\A[a-z][a-z0-9_.]*==[^,\s]+,[a-z][a-z0-9_]*\z/i) }
+        raise ConfigError, "invalid Decode As rules" unless valid
+      end
+    end
+  end
+end

data/lib/vanken/config/columns.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require_relative "yaml_file"
+
+module Vanken
+  module Config
+    class Columns
+      BUILTINS = [[:no, "No.", 64], [:time, "Time", 128], [:source, "Source", 164],
+        [:destination, "Destination", 164], [:protocol, "Protocol", 90], [:length, "Length", 76], [:info, "Info", 560]].freeze
+
+      def self.load(directory:, legacy: [])
+        path = File.join(directory, "columns.yml")
+        raise ConfigError, "columns configuration must not be a symlink" if File.symlink?(path)
+        return new(YamlFile.read(path)) if File.file?(path)
+        settings = new
+        unless legacy.empty?
+          ordered = settings.to_h["columns"].sort_by { |column| legacy.index { |item| item["key"] == column["key"] } || legacy.size }
+          ordered.each do |column|
+            saved = legacy.find { |item| item["key"] == column["key"] }
+            column.merge!(saved.slice("width", "visible")) if saved
+          end
+          settings.replace("schema_version" => 1, "columns" => ordered)
+        end
+        settings
+      end
+
+      def initialize(payload = nil)
+        payload ||= {"schema_version" => 1, "columns" => BUILTINS.map do |key, label, width|
+          {"key" => key.to_s, "label" => label, "width" => width, "visible" => true, "field" => nil}
+        end}
+        replace(payload)
+      end
+
+      def replace(payload)
+        raise ConfigError, "unsupported columns schema" unless payload.is_a?(Hash) && payload["schema_version"] == 1
+        items = payload["columns"]
+        raise ConfigError, "columns must contain between 1 and 64 entries" unless items.is_a?(Array) && items.size.between?(1, 64)
+        rows = items.map do |item|
+          raise ConfigError, "invalid column" unless item.is_a?(Hash)
+          key, label, width, visible, field = item.values_at("key", "label", "width", "visible", "field")
+          custom = self.class.valid_field?(field) && key == "field:#{field}"
+          builtin = field.nil? && BUILTINS.any? { |entry| entry.first.to_s == key }
+          raise ConfigError, "invalid column key or field" unless key.is_a?(String) && (custom || builtin)
+          raise ConfigError, "invalid column label" unless label.is_a?(String) && !label.empty? && label.bytesize <= 256 && !label.include?("\0")
+          raise ConfigError, "invalid column width or visibility" unless width.is_a?(Numeric) && width.finite? && width.between?(40, 4096) && [true, false].include?(visible)
+          {"key" => key.dup.freeze, "label" => label.dup.freeze, "width" => width, "visible" => visible, "field" => field&.dup&.freeze}.freeze
+        end
+        raise ConfigError, "duplicate columns" unless rows.map { |item| item["key"] }.uniq.size == rows.size
+        @columns = rows.freeze
+        self
+      end
+
+      def self.valid_field?(field)
+        field.is_a?(String) && field.bytesize <= 256 && /\A[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+)+\z/.match?(field)
+      end
+
+      def to_h = {"schema_version" => 1, "columns" => @columns.map(&:dup)}
+      def custom = @columns.select { |column| column["field"] }
+      def table_columns
+        @columns.map do |column|
+          key = column.fetch("key").to_sym
+          {key: key, label: column.fetch("label"), width: column.fetch("width"), visible: column.fetch("visible"),
+           align: %i[no time length].include?(key) ? :end : :start}
+        end
+      end
+
+      def add(field, label: field, width: 120)
+        raise ConfigError, "invalid custom field name" unless self.class.valid_field?(field)
+        key = "field:#{field}"
+        rows = to_h["columns"]
+        existing = rows.find { |item| item["key"] == key }
+        if existing
+          existing["visible"] = true
+        else
+          rows << {"key" => key, "label" => label, "width" => width, "visible" => true, "field" => field}
+        end
+        replace("schema_version" => 1, "columns" => rows)
+        key
+      end
+
+      def remove(key)
+        raise ConfigError, "hide builtin columns instead of removing them" unless custom.any? { |item| item["key"] == key.to_s }
+        replace("schema_version" => 1, "columns" => to_h["columns"].reject { |item| item["key"] == key.to_s })
+      end
+
+      def move(key, index)
+        rows = to_h["columns"]
+        raise ConfigError, "column position is outside the list" unless index.is_a?(Integer) && index.between?(0, rows.size - 1)
+        item = rows.find { |column| column["key"] == key.to_s } || raise(ConfigError, "unknown column")
+        rows.delete(item)
+        rows.insert(index, item)
+        replace("schema_version" => 1, "columns" => rows)
+      end
+
+      def update_layout(items)
+        rows = items.map do |item|
+          key = item.fetch(:key).to_s
+          saved = @columns.find { |column| column["key"] == key } || raise(ConfigError, "unknown column")
+          saved.merge("width" => item.fetch(:width), "visible" => item.fetch(:visible))
+        end
+        raise ConfigError, "column layout is incomplete" unless rows.size == @columns.size
+        replace("schema_version" => 1, "columns" => rows)
+      rescue KeyError, NoMethodError
+        raise ConfigError, "invalid column layout"
+      end
+
+      def save(directory)
+        path = File.join(directory, "columns.yml")
+        raise ConfigError, "columns configuration must not be a symlink" if File.symlink?(directory) || File.symlink?(path)
+        YamlFile.write(path, to_h)
+      end
+
+      def self.display(values, type: nil)
+        # ponytail: cap a cell at 16 values and 4096 bytes; the details and byte panes retain full data.
+        text = values.first(16).map do |value|
+          text = type == :bytes && value.is_a?(String) ? value.byteslice(0, 1024).unpack1("H*") : value.to_s.byteslice(0, 1024)
+          escaped = text.b.gsub(/[^\x20-\x7e]/n) { |byte| format("\\x%02x", byte.getbyte(0)) }
+          escaped += "…" if value.to_s.bytesize > 1024
+          escaped
+        end.join(", ")
+        text = text.byteslice(0, 4096).force_encoding(Encoding::UTF_8).scrub + "…" if text.bytesize > 4096 || values.size > 16
+        text
+      end
+
+      def self.sort_value(value, type: nil)
+        return [2, 0] if value.nil?
+        return [0, value] if value.is_a?(Numeric)
+        return [0, value ? 1 : 0] if [true, false].include?(value)
+        return [0, IPAddr.new(value.to_s).ipv4? ? 4 : 6, IPAddr.new(value.to_s).to_i] if type == :address
+        return [0, value.to_s.delete(".:-").to_i(16)] if type == :mac
+        [1, value.to_s.b]
+      rescue ArgumentError
+        [1, value.to_s.b]
+      end
+    end
+  end
+end

data/lib/vanken/config/messages.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Vanken
+  module Config
+    module Messages
+      EN = {
+        "TCP ストリームを追跡" => "Follow TCP Stream", "別プロトコルとして解析" => "Decode As",
+        "注記" => "note", "警告" => "warning", "エラー" => "error", "トラフィック" => "traffic",
+        "開く" => "Open", "名前を付けて保存" => "Save as", "ファイルを閉じる" => "Close file", "再読み込み" => "Reload",
+        "終了" => "Quit", "設定" => "Preferences", "キャプチャ開始／停止" => "Start or stop capture", "キャプチャ再開" => "Restart capture",
+        "フィルタを適用" => "Apply filter", "フィルタをクリア" => "Clear filter", "フィルタ履歴" => "Filter history", "フィルタを保存" => "Save filter",
+        "選択した項目でフィルタ" => "Filter by selected field", "選択した項目のフィルタを準備" => "Prepare filter from selected field",
+        "表示する列" => "Visible columns", "末尾追従" => "Follow tail", "末尾追従 ✓" => "Follow tail ✓",
+        "拡大" => "Zoom in", "縮小" => "Zoom out", "標準サイズ" => "Reset zoom",
+        "前のパケット" => "Previous packet", "次のパケット" => "Next packet", "最初のパケット" => "First packet", "最後のパケット" => "Last packet",
+        "パケットへ移動" => "Go to packet", "項目をフィルタとしてコピー" => "Copy field as filter",
+        "パケット検索" => "Find packet", "次を検索" => "Find next", "前を検索" => "Find previous",
+        "マーク／解除" => "Mark or unmark packet", "表示中をすべてマーク" => "Mark all displayed packets", "すべてのマークを解除" => "Unmark all packets",
+        "無視／解除" => "Ignore or unignore packet", "時刻基準／解除" => "Set or unset time reference", "同一会話の前" => "Previous in conversation", "同一会話の次" => "Next in conversation",
+        "色付けルール" => "Coloring rules", "色付け" => "Packet coloring", "エキスパート情報" => "Expert information",
+        "プラグイン再読み込み" => "Reload plugins", "ディセクタプラグイン" => "Dissector plugins", "キャプチャファイルのプロパティ" => "Capture file properties",
+        "プロトコル階層" => "Protocol hierarchy", "会話" => "Conversations", "端点" => "Endpoints", "I/O グラフ" => "I/O graph",
+        "指定パケットのエクスポート" => "Export specified packets", "解析結果のエクスポート" => "Export dissections", "コマンドパレット" => "Command palette", "プロファイル" => "Profiles",
+        "時刻: %{name}" => "Time: %{name}", "テーマ: %{name}" => "Theme: %{name}", "選択項目" => "Selected field", "選択項目を除外" => "Exclude selected field",
+        "適用: %{label}" => "Apply: %{label}", "準備: %{label}" => "Prepare: %{label}", "16 進数" => "Hexadecimal", "テキスト" => "Text", "ダンプ" => "Hex dump",
+        "エスケープした文字列" => "Escaped text", "バイトをコピー: %{label}" => "Copy bytes: %{label}",
+        "ファイル" => "File", "編集" => "Edit", "表示" => "View", "時刻形式" => "Time format", "テーマ" => "Theme", "移動" => "Go",
+        "キャプチャ" => "Capture", "フィルタ" => "Filter", "選択項目を適用" => "Apply selected field", "選択項目から準備" => "Prepare from selected field",
+        "分析" => "Analyze", "統計" => "Statistics", "ヘルプ" => "Help", "表示中のパケットのみ" => "Displayed packets only",
+        "%{value}秒" => "%{value} s", "間隔" => "Interval", "系列の表示フィルタ（1行に1系列、空行は全件）" => "Series display filters (one per line; blank means all packets)",
+        "系列を適用" => "Apply series", "表示するパケットがありません。" => "There are no packets to display.", "全件 %{index}" => "All packets %{index}",
+        "先頭の%{count}区間を省略しています。間隔を広げると全期間を表示できます。" => "The first %{count} intervals are omitted. Select a wider interval to show the entire capture.",
+        "TCPストリームを持つパケットを選択してください。" => "Select a packet with a TCP stream.", "ストリーム番号" => "Stream number",
+        "16進ダンプ" => "Hex dump", "生データ（保存用）" => "Raw data (for saving)", "表示形式" => "Display format", "両方向" => "Both directions",
+        "クライアント → サーバー" => "Client → server", "サーバー → クライアント" => "Server → client", "方向" => "Direction",
+        "ストリーム番号は0以上の整数で指定してください。" => "The stream number must be a nonnegative integer.", "文字列検索" => "Find text",
+        "保存" => "Save", "このストリームを除外" => "Exclude this stream", "表示は16 MiBまでです。保存は全量を含みます。" => "The display is limited to 16 MiB. Saving includes the entire stream.",
+        "範囲（1-10,20,30-）" => "Range (1-10,20,30-)", "無視したパケットを除外" => "Exclude ignored packets", "全件" => "All packets", "表示中" => "Displayed",
+        "選択" => "Selected", "マーク済み" => "Marked", "最初と最後のマークの間" => "Between first and last marks", "範囲指定" => "Packet range", "対象" => "Scope",
+        "形式" => "Format", "エクスポート" => "Export", "解析結果" => "Dissections", "パケット" => "Packets", "%{kind}のエクスポート" => "Export %{kind}",
+        "SHA-256を計算" => "Calculate SHA-256", "集計中…" => "Calculating…", "メモリ上限により%{count}行が省略されました。" => "%{count} rows were omitted because of the memory limit.",
+        "フィルタとして適用" => "Apply as filter", "エクスポート先" => "Export destination", "未記録" => "Not recorded", "未保存" => "Unsaved",
+        "期間（秒）" => "Duration (seconds)", "合計（bytes）" => "Total bytes", "保存済み（bytes）" => "Captured bytes", "平均pps" => "Average packets/s", "平均bps" => "Average bits/s",
+        "インタフェース %{name}" => "Interface %{name}", "取得統計 %{key}" => "Capture statistics %{key}",
+        "検索内容" => "Search query", "表示フィルタ" => "Display filter", "16 進" => "Hex", "文字列" => "String", "正規表現" => "Regular expression",
+        "パケット一覧" => "Packet list", "パケット詳細" => "Packet details", "パケットバイト" => "Packet bytes", "検索対象" => "Search in", "キャンセル" => "Cancel",
+        "一致するパケットはありません。" => "No matching packets were found.", "ルール" => "Rule", "名前" => "Name", "有効" => "Enabled",
+        "ライト" => "Light", "ダーク" => "Dark", "文字" => "Text color", "背景" => "Background", "削除" => "Delete", "追加" => "Add", "新しいルール" => "New rule",
+        "%{theme} %{part}" => "%{theme} %{part}", "インポート" => "Import", "適用" => "Apply", "色付けルールの読み込み先" => "Import coloring rules", "色付けルールの保存先" => "Export coloring rules",
+        "インタフェース" => "Interface", "キャプチャフィルタ (BPF)" => "Capture filter (BPF)", "バッファサイズ (bytes)" => "Buffer size (bytes)",
+        "停止件数 (0: 無制限)" => "Stop after packet count (0: unlimited)", "停止までの秒数 (0: 無制限)" => "Stop after seconds (0: unlimited)", "停止サイズ (bytes、0: 無制限)" => "Stop after bytes (0: unlimited)",
+        "リング保存先 (空欄: 保存しない)" => "Ring file path (blank: disabled)", "リングファイル上限 (bytes)" => "Ring file size limit (bytes)", "リング切替間隔 (秒)" => "Ring rotation interval (seconds)", "リングファイル数" => "Ring file count",
+        "プロミスキャスモード" => "Promiscuous mode", "送受信" => "Inbound and outbound", "受信" => "Inbound", "送信" => "Outbound",
+        "インタフェースを取得中です。" => "Loading interfaces…", "GUI は通常ユーザーで動作し、取得ヘルパーに必要な権限を渡します。" => "The application runs as your user and grants the capture helper the required permissions.",
+        "開始" => "Start", "停止" => "Stop", "再開" => "Restart", "キャプチャオプション" => "Capture options", "時刻表示" => "Time display", "文字を小さく" => "Smaller text", "文字を大きく" => "Larger text",
+        "ファイルを開く" => "Open file", "キャプチャを停止してから操作してください。" => "Stop the capture before continuing.", "キャプチャ中" => "Capturing",
+        "このキャプチャはまだ保存されていません。" => "This capture has not been saved.", "破棄" => "Discard", "キャプチャを保存しますか？" => "Save this capture?",
+        "指定したパケットは表示されていません" => "The specified packet is not displayed", "%{message} (位置 %{position})" => "%{message} (position %{position})",
+        "フィルタとしてコピー" => "Copy as filter", "フィルタを準備" => "Prepare filter", "フィルタの名前" => "Filter name",
+        "プロファイルの管理" => "Manage profiles", "複製" => "Duplicate", "新しいプロファイル名" => "New profile name", "新規作成" => "Create profile", "例: udp.port==8443,dns" => "Example: udp.port==8443,dns",
+        "Ruby ディセクタのパス" => "Ruby dissector path", "Ruby プラグインはユーザー権限で任意のコードを実行します。信頼するファイルだけを読み込んでください。\n%{paths}" => "Ruby plugins can execute arbitrary code as your user. Load only files you trust.\n%{paths}",
+        "信頼して読み込む" => "Trust and load", "プラグインの確認" => "Confirm plugins", "コマンドを検索" => "Search commands", "解析" => "Analysis", "名前解決" => "Name resolution",
+        "キャプチャファイルを開くか、インタフェースを選んで開始してください" => "Open a capture file or select an interface to start capturing.",
+        "読み込み中" => "Loading", "%{state} %{count} / %{total}   表示 %{displayed}   ドロップ %{dropped}" => "%{state} %{count} / %{total}   Displayed %{displayed}   Dropped %{dropped}",
+        "操作を完了できません" => "The operation could not be completed", "読み込みを中止" => "Cancel loading", "クリア" => "Clear", "履歴" => "History",
+        "パケットキャプチャを開くか、インタフェースを選択してキャプチャを開始します。" => "Open a packet capture or select an interface to start capturing.",
+        "キャプチャファイルを開く" => "Open capture file", "インタフェースを選択" => "Select interface",
+        "上へ移動" => "Move up", "下へ移動" => "Move down", "項目名" => "Column name", "表示フィールド" => "Display field", "列幅" => "Column width",
+        "列として適用" => "Apply as column", "カスタム列を追加" => "Add custom column", "カスタム列" => "Custom columns", "列の名前" => "Column label", "フィールド名" => "Field name",
+        "時刻" => "Time", "送信元" => "Source", "宛先" => "Destination", "プロトコル" => "Protocol", "長さ" => "Length", "情報" => "Info",
+        "重大度" => "Severity", "コード" => "Code", "件数" => "Count", "メッセージ" => "Message", "アドレス A" => "Address A", "ポート A" => "Port A", "アドレス B" => "Address B", "ポート B" => "Port B",
+        "パケット A → B" => "Packets A → B", "パケット B → A" => "Packets B → A", "バイト A → B" => "Bytes A → B", "バイト B → A" => "Bytes B → A",
+        "アドレス" => "Address", "ポート" => "Port", "送信パケット" => "Transmitted packets", "受信パケット" => "Received packets", "送信バイト" => "Transmitted bytes", "受信バイト" => "Received bytes", "期間（ns）" => "Duration (ns)",
+        "言語" => "Language", "文字サイズ" => "Font size", "時刻の精度" => "Time precision", "自動スクロール" => "Autoscroll", "行キャッシュ容量" => "Row cache size",
+        "チェックサム検証" => "Verify checksums", "解析メモリ上限（MiB）" => "Analysis memory limit (MiB)", "フロー数上限" => "Maximum flows", "ワーカー数" => "Workers",
+        "キャプチャ方式" => "Capture backend", "ヘルパー起動方式" => "Helper launcher", "解決タイムアウト（秒）" => "Resolution timeout (seconds)", "名前キャッシュ容量" => "Name cache size",
+        "保存せずに閉じる" => "Close without saving", "復旧可能なセッション" => "Recoverable sessions", "復旧" => "Recover", "一時セッションを復旧しますか？" => "Recover temporary sessions?",
+        "相対時刻" => "Relative time", "絶対時刻" => "Absolute time", "前パケットとの差" => "Delta from previous packet", "前表示パケットとの差" => "Delta from previous displayed packet", "エポック時刻" => "Epoch time",
+        "システム設定" => "System", "ハイコントラスト" => "High contrast", "ミリ秒" => "Milliseconds", "マイクロ秒" => "Microseconds", "ナノ秒" => "Nanoseconds",
+        "前回のキャプチャを復旧" => "Recover previous capture",
+        "%{label} %{count} / %{total}   表示 %{displayed}   ドロップ %{dropped}%{progress}" => "%{label} %{count} / %{total}   Displayed %{displayed}   Dropped %{dropped}%{progress}",
+        "幅" => "Width", "列名 (空欄: フィールド名)" => "Column label (blank: field name)", "幅は40から4096の範囲で指定してください" => "Width must be between 40 and 4096",
+        "%{protocol}   %{packets} パケット   %{bytes} bytes   %{percent}%" => "%{protocol}   %{packets} packets   %{bytes} bytes   %{percent}%",
+        "区間ごとのパケット数" => "Packets per interval", "%{count} パケット" => "%{count} packets", "キャプチャファイル" => "Capture files", "閉じる" => "Close",
+        "取得バッファ (bytes)" => "Capture buffer (bytes)", "取得方向" => "Capture direction",
+        "自動停止: パケット数 (0: 無効)" => "Stop after packet count (0: disabled)", "自動停止: 秒 (0: 無効)" => "Stop after seconds (0: disabled)", "自動停止: bytes (0: 無効)" => "Stop after bytes (0: disabled)",
+        "リング保存先 (空欄: 無効)" => "Ring file path (blank: disabled)", "リング: ファイルごとのbytes" => "Ring: bytes per file", "リング: 秒" => "Ring: seconds", "リング: 保持ファイル数" => "Ring: retained files",
+        "検索形式" => "Search mode", "キャプチャ操作" => "Capture controls", "日本語" => "Japanese", "英語" => "English", "自動" => "Automatic", "直接" => "Direct",
+        "マーク" => "Mark", "マークを解除" => "Unmark", "無視" => "Ignore", "無視を解除" => "Unignore", "時刻基準にする" => "Set time reference", "時刻基準を解除" => "Unset time reference", "双方向" => "Both directions", "フィルタ履歴はまだありません。" => "There is no filter history yet."
+      }.freeze #: Hash[String, String]
+      JA = EN.invert.freeze #: Hash[String, String]
+
+      # @rbs (String text, ?language: String, **untyped values) -> String
+      def self.translate(text, language: "ja", **values)
+        dictionary = case language
+        when "ja" then JA
+        when "en" then EN
+        else raise Vanken::ConfigError, "invalid language: #{language}"
+        end
+        dictionary.fetch(text, text).gsub(/%\{(\w+)\}/) { values.fetch(Regexp.last_match(1).to_sym).to_s }
+      end
+    end
+  end
+end

data/lib/vanken/config/preferences.rb

@@ -5,6 +5,7 @@ require "yaml"
 require "fileutils"
 require "logger"
 require "tempfile"
+require_relative "yaml_file"
 
 module Vanken
   module Config
@@ -25,22 +26,32 @@ module Vanken
     class Preferences
       DEFAULTS = {
         "schema_version" => 1,
-        "appearance" => {"theme" => "system", "font_size" => 13, "language" => "ja"},
-        "packet_list" => {"time_format" => "relative", "time_precision" => "micro", "autoscroll" => true, "row_cache_rows" => 20_000},
-        "capture" => {"snaplen" => 262_144, "promiscuous" => true, "buffer_size" => 4 << 20, "backend" => "auto", "launcher" => "auto", "direction" => "inout"},
+        "appearance" => {"theme" => "system", "font_size" => 13, "language" => ENV.fetch("LANG", "en").start_with?("ja") ? "ja" : "en"},
+        "packet_list" => {"time_format" => "relative", "time_precision" => "micro", "autoscroll" => true, "row_cache_rows" => 20_000, "coloring" => true},
+        "capture" => {"snaplen" => 262_144, "promiscuous" => true, "buffer_size" => 4 << 20, "backend" => "auto", "launcher" => "auto", "direction" => "inout",
+          "stop_count" => 0, "stop_duration" => 0.0, "stop_bytes" => 0, "ring_path" => "", "ring_max_bytes" => 0, "ring_interval" => 0.0, "ring_file_count" => 10},
+        "name_resolution" => {"enabled" => false, "timeout" => 1.0, "cache_size" => 256},
         "analysis" => {"verify_checksums" => false, "max_state_mib" => 256, "max_flows" => 100_000, "workers" => 4},
         "history" => [], "recent_files" => [], "bookmarks" => {}, "layout" => {"ratios" => [0.55, 0.6], "width" => 1280, "height" => 800, "columns" => []}
       }.freeze
       attr_reader :warning, :directory
 
-      def initialize(directory: Paths.config)
+      def initialize(directory: Paths.config, state_directory: nil)
         @directory = directory
+        @state_directory = state_directory || (directory == Paths.config ? Paths.state : File.join(directory, "state"))
         @values = Marshal.load(Marshal.dump(DEFAULTS))
         path = File.join(directory, "preferences.yml")
-        return unless File.file?(path)
-        saved = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
-        raise Vanken::ConfigError, "unsupported preferences schema" unless saved.is_a?(Hash) && saved["schema_version"] == 1
-        merge(@values, saved)
+        if File.file?(path)
+          saved = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
+          raise Vanken::ConfigError, "unsupported preferences schema" unless saved.is_a?(Hash) && saved["schema_version"] == 1
+          merge(@values, saved)
+        end
+        state = YamlFile.read(File.join(@state_directory, "recent.yml"))
+        merge(@values, state.slice("history", "recent_files"))
+        window = YamlFile.read(File.join(@state_directory, "window_state.yml"))
+        merge(@values["layout"], window.slice("width", "height", "ratios"))
+        filters = YamlFile.read(File.join(@directory, "filters.yml"))
+        merge(@values, filters.slice("bookmarks"))
         validate
       rescue Psych::Exception, Vanken::ConfigError, SystemCallError, TypeError => error
         @values = Marshal.load(Marshal.dump(DEFAULTS))
@@ -78,6 +89,9 @@ module Vanken
         temporary.fsync
         temporary.close
         File.rename(temporary.path, File.join(@directory, "preferences.yml"))
+        YamlFile.write(File.join(@state_directory, "recent.yml"), @values.slice("history", "recent_files"))
+        YamlFile.write(File.join(@state_directory, "window_state.yml"), @values["layout"].slice("width", "height", "ratios"))
+        YamlFile.write(File.join(@directory, "filters.yml"), @values.slice("bookmarks"))
       ensure
         temporary&.close unless temporary&.closed?
         File.unlink(temporary.path) if temporary && File.exist?(temporary.path)
@@ -99,6 +113,7 @@ module Vanken
         validate_shape(DEFAULTS, @values)
         raise Vanken::ConfigError, "invalid theme" unless %w[system dark light high_contrast].include?(get("appearance.theme"))
         raise Vanken::ConfigError, "invalid font size" unless get("appearance.font_size").is_a?(Integer) && get("appearance.font_size").between?(8, 32)
+        raise Vanken::ConfigError, "invalid language" unless %w[ja en].include?(get("appearance.language"))
         raise Vanken::ConfigError, "invalid time format" unless %w[relative absolute delta delta_displayed epoch].include?(get("packet_list.time_format"))
         raise Vanken::ConfigError, "invalid time precision" unless %w[milli micro nano].include?(get("packet_list.time_precision"))
         raise Vanken::ConfigError, "invalid history" unless history.all? { |item| item.is_a?(String) } && recent_files.all? { |item| item.is_a?(String) } && bookmarks.all? { |name, expression| name.is_a?(String) && expression.is_a?(String) }
@@ -111,6 +126,17 @@ module Vanken
         columns = get("layout.columns")
         raise Vanken::ConfigError, "invalid columns" unless columns.all? { |column| column.is_a?(Hash) && %w[no time source destination protocol length info].include?(column["key"]) && column["width"].is_a?(Numeric) && column["width"].finite? && column["width"].between?(40, 4096) && [true, false].include?(column["visible"]) } && columns.map { |column| column["key"] }.uniq.size == columns.size
         raise Vanken::ConfigError, "invalid capture settings" unless %w[auto direct sudo pkexec].include?(get("capture.launcher")) && %w[auto ring socket bpf].include?(get("capture.backend")) && %w[in out inout].include?(get("capture.direction"))
+        %w[capture.stop_count capture.stop_bytes capture.ring_max_bytes].each do |path|
+          raise ConfigError, "invalid #{path}" unless get(path).is_a?(Integer) && get(path).between?(0, (1 << 63) - 1)
+        end
+        %w[capture.stop_duration capture.ring_interval].each do |path|
+          value = get(path)
+          raise ConfigError, "invalid #{path}" unless value.is_a?(Numeric) && value.finite? && value >= 0
+        end
+        raise ConfigError, "invalid ring file count" unless get("capture.ring_file_count").between?(1, 10_000)
+        raise ConfigError, "invalid ring path" if get("capture.ring_path").include?("\0")
+        raise ConfigError, "invalid resolver timeout" unless get("name_resolution.timeout").finite? && get("name_resolution.timeout").between?(0.01, 10)
+        raise ConfigError, "invalid resolver cache size" unless get("name_resolution.cache_size").between?(1, 10_000)
       rescue NoMethodError, KeyError
         raise Vanken::ConfigError, "invalid preferences shape"
       end

data/lib/vanken/config/profiles.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "preferences"
+require_relative "yaml_file"
+
+module Vanken
+  module Config
+    class Profiles
+      FILES = %w[preferences.yml coloring_rules.yml columns.yml filters.yml decode_as.yml plugins.yml].freeze
+      attr_reader :directory, :active
+
+      def initialize(directory: Paths.config)
+        @directory = File.expand_path(directory)
+        @active = YamlFile.read(File.join(@directory, "profiles.yml"), default: {"active" => "default"}).fetch("active", "default")
+        profile_directory(@active)
+        @active = "default" unless names.include?(@active)
+      end
+
+      def names
+        ["default", *Dir.glob(File.join(@directory, "profiles", "*")).select { |path| File.directory?(path) && !File.symlink?(path) }.map { |path| File.basename(path) }.sort]
+      end
+
+      def preferences
+        shared = @directory == File.expand_path(Paths.config) ? Paths.state : File.join(@directory, "state")
+        Preferences.new(directory: profile_directory(@active), state_directory: shared)
+      end
+
+      def create(name, copy_from: nil)
+        target = profile_directory(name)
+        raise ConfigError, "profile already exists" if names.include?(name) || File.exist?(target) || File.symlink?(target)
+        raise ConfigError, "unknown profile" if copy_from && !names.include?(copy_from)
+        FileUtils.mkdir_p(File.dirname(target), mode: 0o700)
+        Dir.mkdir(target, 0o700)
+        if copy_from
+          source = profile_directory(copy_from)
+          FILES.each do |file|
+            path = File.join(source, file)
+            next unless File.file?(path)
+            raise ConfigError, "profile file must not be a symlink" if File.symlink?(path)
+            File.write(File.join(target, file), File.binread(path), mode: "wb", perm: 0o600)
+          end
+        else
+          Preferences.new(directory: target).save
+        end
+        name
+      end
+
+      def switch(name)
+        profile_directory(name)
+        raise ConfigError, "unknown profile" unless names.include?(name)
+        @active = name
+        YamlFile.write(File.join(@directory, "profiles.yml"), "active" => name)
+        preferences
+      end
+
+      def delete(name)
+        path = profile_directory(name)
+        raise ConfigError, "cannot delete the active or default profile" if name == @active || name == "default"
+        raise ConfigError, "unknown profile" unless names.include?(name)
+        FileUtils.remove_entry_secure(path)
+      end
+
+      private
+
+      def profile_directory(name)
+        raise ConfigError, "invalid profile name" unless name.is_a?(String) && name.match?(/\A[\p{L}\p{N}_ -][\p{L}\p{N}_. -]{0,63}\z/) && !%w[. ..].include?(name)
+        path = name == "default" ? @directory : File.join(@directory, "profiles", name)
+        raise ConfigError, "profiles directory must not be a symlink" if name != "default" && File.symlink?(File.join(@directory, "profiles"))
+        raise ConfigError, "profile must not be a symlink" if File.symlink?(path)
+        path
+      end
+    end
+  end
+end

data/lib/vanken/config/sessions.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "json"
+
+module Vanken
+  module Config
+    module Sessions
+      def self.candidates(parent: Dir.tmpdir)
+        Dir.glob(File.join(parent, "vanken-*" )).select { |directory| orphan?(directory) }.sort
+      end
+
+      def self.recover(directory, parent: Dir.tmpdir, **options)
+        with_session(directory, parent: parent) { App::Document.recover(directory, **options) }
+      end
+
+      def self.discard(directory, parent: Dir.tmpdir)
+        store = with_session(directory, parent: parent) { Core::FrameStore.recover(directory) }
+        store.close
+      end
+
+      def self.orphan?(directory)
+        return false unless File.directory?(directory) && !File.symlink?(directory)
+        stat = File.stat(directory)
+        return false unless stat.uid == Process.uid && (stat.mode & 0o077).zero?
+        Dir.children(directory).each do |name|
+          stat = File.lstat(File.join(directory, name))
+          return false unless stat.file? && stat.uid == Process.uid && stat.nlink == 1
+        end
+        path = File.join(directory, "session.json")
+        return false unless File.file?(path) && File.size(path) <= 65_536
+        return false unless %w[frames.bin frames.idx].all? { |name| File.file?(File.join(directory, name)) }
+        session = JSON.parse(File.read(path))
+        pid = session["pid"]
+        return false unless session["schema_version"] == 1 && pid.is_a?(Integer) && pid.positive?
+        begin
+          Process.kill(0, pid)
+          false
+        rescue Errno::ESRCH
+          true
+        rescue Errno::EPERM
+          false
+        end
+      rescue SystemCallError, JSON::ParserError, TypeError, NoMethodError
+        false
+      end
+
+      def self.with_session(directory, parent:)
+        path = File.expand_path(directory)
+        raise Vanken::FileError, "session is active or unsafe" unless candidates(parent: parent).include?(path)
+        File.open(File.join(path, "session.json"), "r+b") do |file|
+          raise Vanken::FileError, "session is being recovered" unless file.flock(File::LOCK_EX | File::LOCK_NB)
+          raise Vanken::FileError, "session is active or unsafe" unless orphan?(path)
+          original = file.read
+          begin
+            yield
+          rescue StandardError
+            file.rewind
+            file.truncate(0)
+            file.write(original)
+            file.flush
+            raise
+          end
+        end
+      end
+      private_class_method :orphan?, :with_session
+    end
+  end
+end

data/lib/vanken/config/yaml_file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "tempfile"
+require "fileutils"
+
+module Vanken
+  module Config
+    module YamlFile
+      def self.read(path, default: {})
+        return default unless File.file?(path)
+        raise ConfigError, "configuration exceeds 1 MiB" if File.size(path) > 1 << 20
+        value = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
+        raise ConfigError, "unsupported configuration schema: #{path}" unless value.is_a?(Hash) && value["schema_version"] == 1
+        value
+      rescue Psych::Exception => error
+        raise ConfigError, error.message
+      end
+
+      def self.write(path, value)
+        directory = File.dirname(path)
+        FileUtils.mkdir_p(directory, mode: 0o700)
+        temporary = Tempfile.create(["vanken-", ".yml"], directory)
+        temporary.chmod(0o600)
+        temporary.write(YAML.dump(value.merge("schema_version" => 1)))
+        temporary.flush
+        temporary.fsync
+        temporary.close
+        File.rename(temporary.path, path)
+      ensure
+        temporary&.close unless temporary&.closed?
+        File.unlink(temporary.path) if temporary && File.exist?(temporary.path)
+      end
+    end
+  end
+end