rubik 0.1.0

data/lib/rubik/security/classifier/commands/yarn.yaml

@@ -0,0 +1,72 @@
+# $schema: ../../../schemas/command.schema.json
+command: yarn
+description: "JavaScript package manager"
+strict: false
+global_options:
+  --help: {overrides: READONLY}
+options:
+  --version: {overrides: READONLY}
+subcommands:
+  install:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+    strict: false
+  add:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+    strict: false
+  remove:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+    strict: false
+  up:
+    classification: LOCAL_EFFECTS
+    strict: false
+  upgrade:
+    classification: LOCAL_EFFECTS
+    strict: false
+  run:
+    classification: DANGEROUS
+    strict: false
+    delegates_to:
+      mode: rest_are_argv
+  exec:
+    classification: DANGEROUS
+    strict: false
+  dlx:
+    classification: DANGEROUS
+    strict: false
+  info:
+    classification: READONLY
+    strict: false
+  why:
+    classification: READONLY
+    strict: false
+  config:
+    subcommands:
+      list:
+        classification: READONLY
+        strict: false
+  workspaces:
+    subcommands:
+      list:
+        classification: READONLY
+        strict: false
+  publish:
+    classification: DANGEROUS
+    strict: false
+  build:
+    classification: LOCAL_EFFECTS
+    strict: false
+  test:
+    classification: LOCAL_EFFECTS
+    strict: false
+  set:
+    classification: LOCAL_EFFECTS
+    strict: false
+  pack:
+    classification: LOCAL_EFFECTS
+    strict: false
+  init:
+    classification: LOCAL_EFFECTS
+    strict: false

data/lib/rubik/security/classifier/commands/yes.yaml

@@ -0,0 +1,7 @@
+# $schema: ../../../schemas/command.schema.json
+command: "yes"
+description: "Output a string repeatedly until killed"
+classification: READONLY
+strict: false
+global_options:
+  --help: {overrides: READONLY}

data/lib/rubik/security/classifier/commands/yq.yaml

@@ -0,0 +1,10 @@
+# $schema: ../../../schemas/command.schema.json
+command: yq
+description: "Command-line YAML processor"
+classification: READONLY
+strict: false
+global_options:
+  --help: {overrides: READONLY}
+options:
+  -i: {overrides: LOCAL_EFFECTS}
+  --inplace: {overrides: LOCAL_EFFECTS, aliases: [-i]}

data/lib/rubik/security/classifier/commands/zip.yaml

@@ -0,0 +1,8 @@
+# $schema: ../../../schemas/command.schema.json
+command: zip
+description: "Package and compress files into ZIP archives"
+classification: LOCAL_EFFECTS
+risk: LOW
+strict: false
+global_options:
+  --help: {overrides: READONLY}

data/lib/rubik/security/classifier/commands/zsh.yaml

@@ -0,0 +1,14 @@
+# $schema: ../../../schemas/command.schema.json
+command: zsh
+description: "Z shell command interpreter"
+classification: DANGEROUS
+global_options:
+  --help: {overrides: READONLY}
+delegates_to:
+  mode: flag_value_is_expression
+  flag: -c
+options:
+  -c: {takes_value: true}
+  -e: {}
+  -x: {}
+  -i: {}

data/lib/rubik/security/classifier/database.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "monitor"
+require "yaml"
+require_relative "models"
+require_relative "pwsh_rules"
+
+module Rubik
+  module Security
+    module Classifier
+      class CommandDatabase
+        include MonitorMixin
+
+        ALIAS_FORBIDDEN_KEYS = [
+          "classification", "risk", "subcommands", "options", "global_options", "subcommand_mode", "delegates_to", "strict"
+        ].freeze
+
+        attr_reader :builtin_dir, :user_dir
+
+        def self.default_commands_dir
+          File.expand_path("commands", __dir__)
+        end
+
+        def self.user_commands_dir
+          cfg = ENV["BASH_CLASSIFY_CONFIG_DIR"] || ENV.fetch("RUBIK_COMMAND_CONFIG_DIR", nil)
+          return File.join(cfg, "commands") if cfg
+
+          File.join(Dir.home, ".config", "rubik", "commands")
+        end
+
+        def initialize(builtin_dir: nil, user_dir: nil)
+          super()
+          @builtin_dir = builtin_dir || self.class.default_commands_dir
+          @user_dir = user_dir || (File.directory?(self.class.user_commands_dir) ? self.class.user_commands_dir : nil)
+          @files = {}
+          @cache = {}
+
+          index_dir(@builtin_dir) if @builtin_dir && File.directory?(@builtin_dir)
+          index_dir(@user_dir) if @user_dir && File.directory?(@user_dir)
+        end
+
+        def [](key, shell: nil)
+          get(key, nil, shell: shell)
+        end
+
+        def get(key, default = nil, shell: nil)
+          return default if key.nil?
+
+          key_s = self.class.yaml_str(key)
+
+          return PwshRules[key_s] if shell == :powershell && PwshRules.key?(key_s)
+
+          synchronize do
+            if @cache.key?(key_s)
+              @cache[key_s]
+            elsif @files.key?(key_s)
+              cmd_def = self.class.load_command_file(@files[key_s])
+              @cache[key_s] = cmd_def
+              cmd_def
+            elsif PwshRules.key?(key_s)
+              PwshRules[key_s]
+            else
+              default
+            end
+          end
+        end
+
+        def key?(key, shell: nil)
+          return false if key.nil?
+
+          key_s = self.class.yaml_str(key)
+          return true if shell == :powershell && PwshRules.key?(key_s)
+
+          @cache.key?(key_s) || @files.key?(key_s) || PwshRules.key?(key_s)
+        end
+
+        def resolve_alias(command_def)
+          return command_def if command_def.nil? || command_def.alias_of.nil?
+
+          target_name = command_def.alias_of
+          target_def = get(target_name)
+          raise ArgumentError, "#{command_def.command} aliases '#{target_name}' which is not in the database" unless target_def
+
+          raise ArgumentError, "alias chain too deep: #{command_def.command} -> #{target_name} -> #{target_def.alias_of}" if target_def.alias_of
+
+          target_def
+        end
+
+        def keys
+          (@files.keys + PwshRules.definitions.keys).uniq
+        end
+
+        def size
+          keys.size
+        end
+
+        def self.yaml_str(value)
+          return "true" if value == true
+          return "false" if value == false
+
+          value.to_s
+        end
+
+        def self.load_command_file(yaml_file)
+          data = YAML.safe_load_file(yaml_file, permitted_classes: [Symbol])
+          raise ArgumentError, "Empty YAML file: #{yaml_file}" if data.nil?
+          raise ArgumentError, "Expected a YAML mapping in #{yaml_file}" unless data.is_a?(Hash)
+
+          command_name = yaml_str(data["command"] || File.basename(yaml_file, ".yaml"))
+          parse_command_def(data, command_name)
+        rescue StandardError => e
+          raise ArgumentError, "Error loading #{yaml_file}: #{e.message}"
+        end
+
+        def self.parse_command_def(data, command_name, is_subcommand: false)
+          raise ArgumentError, "command '#{command_name}': 'aliases' is only valid on subcommands; use alias_of" if data.key?("aliases") && !is_subcommand
+
+          if data.key?("alias_of")
+            conflicting = ALIAS_FORBIDDEN_KEYS & data.keys
+            raise ArgumentError, "alias file for '#{command_name}' combines alias_of with: #{conflicting.join(', ')}" if conflicting.any?
+
+            return CommandDef.new(command: command_name, alias_of: yaml_str(data["alias_of"]))
+          end
+
+          CommandDef.new(
+            command: command_name,
+            description: data["description"],
+            aliases: parse_aliases(data["aliases"], command_name),
+            classification: Classification.normalize(data["classification"]),
+            risk: Risk.normalize(data["risk"]),
+            global_options: parse_options(data["global_options"]),
+            subcommands: parse_subcommands(data["subcommands"]),
+            options: parse_options(data["options"]),
+            strict: data.fetch("strict", true),
+            subcommand_mode: data["subcommand_mode"] == "match_all" ? :match_all : :hierarchical,
+            delegates_to: parse_delegation_config(data["delegates_to"])
+          )
+        end
+
+        def self.parse_options(raw)
+          return {} unless raw.is_a?(Hash)
+
+          options = {}
+          raw.each do |name, props|
+            props = {} unless props.is_a?(Hash)
+            aliases = (props["aliases"] || []).map { |a| yaml_str(a) }
+            opt_def = OptionDef.new(
+              takes_value: props.fetch("takes_value", false),
+              aliases: aliases,
+              overrides: Classification.normalize(props["overrides"]),
+              risk: Risk.normalize(props["risk"]),
+              captures_directory: props.fetch("captures_directory", false),
+              delegates_to: parse_delegation_config(props["delegates_to"])
+            )
+            options[name] = opt_def
+            aliases.each { |a| options[a] = opt_def }
+          end
+          options
+        end
+
+        def self.parse_aliases(raw, command_name)
+          return [] if raw.nil?
+          raise ArgumentError, "subcommand '#{command_name}': 'aliases' must be a list" unless raw.is_a?(Array)
+
+          raw.map { |a| yaml_str(a) }
+        end
+
+        def self.parse_subcommands(raw)
+          return {} unless raw.is_a?(Hash)
+
+          subcommands = {}
+          raw.each do |name, props|
+            canonical = yaml_str(name)
+            subcommands[canonical] = parse_command_def(props || {}, canonical, is_subcommand: true)
+          end
+
+          aliased_by = {}
+          subcommands.dup.each do |canonical, definition|
+            definition.aliases.each do |alias_name|
+              raise ArgumentError, "subcommand '#{canonical}' declares alias '#{alias_name}' already a subcommand" if subcommands.key?(alias_name)
+              raise ArgumentError, "alias '#{alias_name}' already declared by '#{aliased_by[alias_name]}'" if aliased_by.key?(alias_name)
+
+              aliased_by[alias_name] = canonical
+            end
+          end
+
+          aliased_by.each { |alias_name, canonical| subcommands[alias_name] = subcommands[canonical] }
+          subcommands
+        end
+
+        def self.parse_delegation_config(raw)
+          return nil unless raw.is_a?(Hash) && raw["mode"]
+
+          DelegationConfig.new(
+            mode: raw["mode"].to_sym,
+            separator: raw["separator"],
+            terminator: raw["terminator"],
+            flag: raw["flag"],
+            strip_assignments: raw.fetch("strip_assignments", false),
+            skip_leading_positionals: raw.fetch("skip_leading_positionals", 0).to_i,
+            min_classification: Classification.normalize(raw["min_classification"])
+          )
+        end
+
+        private
+
+        def index_dir(dir)
+          Dir.glob(File.join(dir, "*.yaml")).each do |path|
+            stem = File.basename(path, ".yaml")
+            @files[stem] = path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubik/security/classifier/matcher/delegation.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "../models"
+
+module Rubik
+  module Security
+    module Classifier
+      module Matcher
+        module Delegation
+          ASSIGNMENT_RE = /\A[A-Za-z_][A-Za-z0-9_]*=/
+
+          def self.handle_delegation(
+            remaining_positional, delegation, database, full_argv,
+            command_def, parse_warnings, &
+          )
+            results = []
+
+            case delegation.mode
+            when DelegationMode::REST_ARE_ARGV
+              inner_argv = remaining_positional.dup
+              inner_argv.shift while delegation.strip_assignments && inner_argv.first&.match?(ASSIGNMENT_RE)
+
+              if inner_argv.any?
+                results << match_inner_command(
+                  inner_argv, database, delegation_mode: "rest_are_argv",
+                                        delegation_source: command_def.command, min_classification: delegation.min_classification,
+                                        parse_warnings: parse_warnings, &
+                )
+              end
+
+            when DelegationMode::AFTER_SEPARATOR
+              separator = delegation.separator || "--"
+              sep_index = remaining_positional.index(separator)
+              if sep_index
+                inner_argv = remaining_positional[(sep_index + 1)..]
+                if inner_argv.any?
+                  results << match_inner_command(
+                    inner_argv, database, delegation_mode: "after_separator",
+                                          delegation_source: separator, min_classification: delegation.min_classification,
+                                          parse_warnings: parse_warnings, &
+                  )
+                end
+              end
+
+            when DelegationMode::ARGS_ARE_EXPRESSION
+              expr_val = full_argv[1..].join(" ")
+              if expr_val.strip.length.positive?
+                require_relative "../parser"
+                inner_invs, nested_warns = Parser.parse(expr_val)
+                record_warnings(parse_warnings, nested_warns)
+                inner_invs.each do |inv|
+                  results << match_inner_command(
+                    inv.argv, database, delegation_mode: "args_are_expression",
+                                        delegation_source: command_def.command, min_classification: delegation.min_classification,
+                                        parse_warnings: parse_warnings, redirects: inv.redirects, &
+                  )
+                end
+              end
+
+            when DelegationMode::FLAG_VALUE_IS_EXPRESSION
+              return results unless delegation.flag
+
+              expr_val = find_flag_value(full_argv, delegation.flag)
+              if expr_val
+                require_relative "../parser"
+                inner_invs, nested_warns = Parser.parse(expr_val)
+                record_warnings(parse_warnings, nested_warns)
+                inner_invs.each do |inv|
+                  results << match_inner_command(
+                    inv.argv, database, delegation_mode: "flag_value_is_expression",
+                                        delegation_source: delegation.flag, min_classification: delegation.min_classification,
+                                        parse_warnings: parse_warnings, redirects: inv.redirects, &
+                  )
+                end
+              end
+            end
+
+            results
+          end
+
+          def self.handle_option_delegation(
+            opt_name, delegation, delegation_tokens, database,
+            parse_warnings, &
+          )
+            return [] unless delegation.mode == DelegationMode::TERMINATED_ARGV
+
+            inner_argv = delegation_tokens.reject { |t| t == "{}" }
+            return [] if inner_argv.empty?
+
+            [match_inner_command(
+              inner_argv, database, delegation_mode: "terminated_argv",
+                                    delegation_source: opt_name, min_classification: delegation.min_classification,
+                                    parse_warnings: parse_warnings, &
+            )]
+          end
+
+          def self.match_inner_command(
+            argv, database, delegation_mode:, delegation_source:,
+            min_classification: nil, parse_warnings: nil, redirects: [], &matcher_proc
+          )
+            inner_inv = CommandInvocation.new(
+              argv: argv, redirects: [], position_in_pipeline: 0,
+              pipeline_length: 1, context: "toplevel", operator_before: nil,
+              is_background: false
+            )
+
+            inner_result = matcher_proc.call(inner_inv, database, parse_warnings)
+
+            reason = inner_result.classification_reason
+            classification = inner_result.classification
+            risk = inner_result.risk
+            if min_classification && Classification.severity(min_classification) > Classification.severity(classification)
+              # Append, never overwrite: the inner's own evidence ("command
+              # not in database", option override) stays visible.
+              floor = "elevated by delegation floor to #{min_classification}"
+              reason = reason ? "#{reason}; #{floor}" : floor
+              classification = Classification.max_severity(classification, min_classification)
+              risk = Risk.max_severity(risk, default_risk(min_classification))
+            end
+
+            risk = clamp_risk(classification, risk)
+
+            InnerCommandResult.new(
+              delegation_mode: delegation_mode,
+              delegation_source: delegation_source,
+              command: inner_result.command,
+              argv: argv.dup,
+              classification: classification,
+              risk: risk,
+              matched_rule: inner_result.matched_rule,
+              inner_commands: inner_result.inner_commands,
+              ignored_options: inner_result.ignored_options,
+              remaining_options: inner_result.remaining_options,
+              classification_reason: reason,
+              overriding_option: inner_result.overriding_option,
+              options: inner_result.options,
+              positionals: inner_result.positionals,
+              redirects: Array(redirects)
+            )
+          end
+
+          def self.find_flag_value(argv, flag)
+            argv.each_with_index do |token, i|
+              return strip_quotes(argv[i + 1]) if token == flag && i + 1 < argv.size
+              return strip_quotes(token[(flag.length + 1)..]) if token.start_with?("#{flag}=")
+            end
+            nil
+          end
+
+          def self.strip_quotes(str)
+            s = str.to_s
+            if s.length >= 2 && ((s.start_with?('"') && s.end_with?('"')) ||
+               (s.start_with?("'") && s.end_with?("'")))
+              return s[1..-2]
+            end
+
+            s
+          end
+
+          def self.record_warnings(collector, warnings)
+            return if collector.nil? || warnings.nil?
+
+            warnings.each do |w|
+              collector << w unless collector.include?(w)
+            end
+          end
+
+          def self.default_risk(classification)
+            case classification
+            when Classification::DANGEROUS, Classification::UNKNOWN
+              Risk::HIGH
+            when Classification::READONLY
+              Risk::LOW
+            else
+              Risk::MEDIUM
+            end
+          end
+
+          def self.clamp_risk(classification, risk)
+            if [Classification::DANGEROUS, Classification::UNKNOWN].include?(classification)
+              Risk::HIGH
+            else
+              risk
+            end
+          end
+        end
+      end
+    end
+  end
+end