rosett-ai 1.3.3

data/lib/rosett_ai/mcp/keyfile.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    # Multi-key authentication store with thread-safe reload.
+    #
+    # Manages a YAML keyfile with salted hashes, expiry dates,
+    # and enable/disable flags. File permissions are enforced
+    # at 0600 or 0400.
+    #
+    # @author hugo
+    # @author claude
+    class Keyfile
+      VERSION = '1.0'
+      MAX_PERMISSIONS = 0o600
+      DEFAULT_FILENAME = 'rosett-ai-mcp-keys.yml'
+      EXPIRY_WARNING_DAYS = 7
+
+      # @param path [String] path to the keyfile
+      def initialize(path)
+        @path = File.expand_path(path)
+        @mutex = Mutex.new
+        @keys = []
+      end
+
+      # Load and validate the keyfile.
+      #
+      # @return [self]
+      # @raise [RosettAi::McpError] if file is missing or invalid
+      def load!
+        @mutex.synchronize do
+          validate_file_exists
+          validate_permissions
+          parse_keyfile
+        end
+        self
+      end
+
+      # Thread-safe reload (for SIGHUP handler).
+      #
+      # @return [void]
+      def reload!
+        load!
+      rescue StandardError => e
+        warn "[rai-mcp] Keyfile reload failed: #{e.message}"
+      end
+
+      # Find a key entry matching the given plaintext.
+      #
+      # @param plaintext [String] the plaintext API key
+      # @return [Hash, nil] matched key entry or nil
+      def find_key(plaintext)
+        @mutex.synchronize do
+          @keys.find do |entry|
+            next unless entry[:enabled]
+            next if expired?(entry)
+
+            KeyHasher.verify_key(plaintext, entry[:key_hash])
+          end
+        end
+      end
+
+      # List enabled keys (without hashes).
+      #
+      # @return [Array<Hash>] enabled key entries
+      def enabled_keys
+        @mutex.synchronize do
+          @keys.select { |k| k[:enabled] }.map { |k| safe_entry(k) }
+        end
+      end
+
+      # Add a new key to the keyfile.
+      #
+      # @param name [String] key name
+      # @param key_hash [String] salted hash
+      # @param expires_at [String, nil] expiry date (ISO 8601)
+      # @return [void]
+      def add_key(name:, key_hash:, expires_at: nil)
+        @mutex.synchronize do
+          @keys << {
+            name: name,
+            algo: 'sha256_salt',
+            key_hash: key_hash,
+            created_at: Time.now.strftime('%Y-%m-%d'),
+            expires_at: expires_at,
+            enabled: true
+          }
+          write_keyfile
+        end
+      end
+
+      # Revoke (disable) a key by name.
+      #
+      # @param name [String] key name
+      # @return [Boolean] true if key was found and revoked
+      def revoke_key(name)
+        @mutex.synchronize do
+          entry = @keys.find { |k| k[:name] == name }
+          return false unless entry
+
+          entry[:enabled] = false
+          write_keyfile
+          true
+        end
+      end
+
+      # Rotate a key: revoke old, return new hash for replacement.
+      #
+      # @param name [String] key name
+      # @return [Hash, nil] new key entry or nil if not found
+      def rotate_key(name)
+        @mutex.synchronize do
+          old = @keys.find { |k| k[:name] == name }
+          return nil unless old
+
+          old[:enabled] = false
+          new_key, new_entry = build_replacement_key(name, old[:expires_at])
+          @keys << new_entry
+          write_keyfile
+          { plaintext: new_key, entry: safe_entry(new_entry) }
+        end
+      end
+
+      # Create an empty keyfile if missing.
+      #
+      # @param path [String] keyfile path
+      # @return [String] expanded path
+      def self.create_if_missing(path)
+        expanded = File.expand_path(path)
+        unless File.exist?(expanded)
+          dir = File.dirname(expanded)
+          FileUtils.mkdir_p(dir)
+          File.write(expanded, { 'version' => VERSION, 'keys' => [] }.to_yaml)
+          File.chmod(0o600, expanded)
+        end
+        expanded
+      end
+
+      private
+
+      def validate_file_exists
+        raise RosettAi::McpError, "Keyfile not found: #{@path}" unless File.exist?(@path)
+      end
+
+      def validate_permissions
+        mode = File.stat(@path).mode & 0o777
+        return if mode <= MAX_PERMISSIONS
+
+        raise RosettAi::McpError,
+              "Keyfile permissions too open: #{format('%04o', mode)} " \
+              "(max #{format('%04o', MAX_PERMISSIONS)}). Run: chmod 0600 #{@path}"
+      end
+
+      def parse_keyfile
+        data = YAML.safe_load_file(@path, permitted_classes: [Symbol])
+        raise RosettAi::McpError, 'Invalid keyfile format' unless data.is_a?(Hash)
+
+        @keys = Array(data['keys']).map { |k| symbolize_key(k) }
+      end
+
+      def symbolize_key(hash)
+        {
+          name: hash['name'],
+          algo: hash['algo'] || 'sha256_salt',
+          key_hash: hash['key_hash'],
+          created_at: hash['created_at'],
+          expires_at: hash['expires_at'],
+          enabled: hash.fetch('enabled', true)
+        }
+      end
+
+      def expired?(entry)
+        return false unless entry[:expires_at]
+
+        Time.parse(entry[:expires_at].to_s) < Time.now
+      rescue ArgumentError
+        false
+      end
+
+      def safe_entry(entry)
+        entry.except(:key_hash)
+      end
+
+      def write_keyfile
+        data = {
+          'version' => VERSION,
+          'keys' => @keys.map { |k| stringify_key(k) }
+        }
+        File.write(@path, data.to_yaml)
+        File.chmod(0o600, @path)
+      end
+
+      def build_replacement_key(name, expires_at)
+        plaintext = KeyHasher.generate_key
+        entry = {
+          name: name,
+          algo: 'sha256_salt',
+          key_hash: KeyHasher.hash_key(plaintext),
+          created_at: Time.now.strftime('%Y-%m-%d'),
+          expires_at: expires_at,
+          enabled: true
+        }
+        [plaintext, entry]
+      end
+
+      def stringify_key(entry)
+        {
+          'name' => entry[:name],
+          'algo' => entry[:algo],
+          'key_hash' => entry[:key_hash],
+          'created_at' => entry[:created_at],
+          'expires_at' => entry[:expires_at],
+          'enabled' => entry[:enabled]
+        }
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/middleware/authentication.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Middleware
+      # Rack middleware for API key authentication.
+      #
+      # Supports multi-key keyfile or single env var modes.
+      # Returns 401 Unauthorized for invalid credentials.
+      #
+      # @author hugo
+      # @author claude
+      class Authentication
+        # @param app [#call] the next Rack application
+        # @param config [#type, #key_source, #keyfile_path, #api_key_env] auth config
+        def initialize(app, config: nil)
+          @app = app
+          @config = config
+          @keyfile = nil
+          validate_auth_type
+          load_keyfile if keyfile_mode?
+          install_sighup_handler if keyfile_mode?
+        end
+
+        # @param env [Hash] Rack environment
+        # @return [Array] Rack response triplet
+        def call(env)
+          case auth_type
+          when 'none'
+            env['rosett_ai.authenticated'] = false
+            @app.call(env)
+          when 'api_key'
+            authenticate_api_key(env)
+          else
+            unauthorized('Unsupported authentication type')
+          end
+        end
+
+        private
+
+        def auth_type
+          @config.respond_to?(:type) ? @config.type : 'api_key'
+        end
+
+        def validate_auth_type
+          type = auth_type
+          return if ['api_key', 'none'].include?(type)
+
+          warn "[rai-mcp] Unsupported auth type: #{type}, falling back to api_key"
+        end
+
+        def keyfile_mode?
+          return false unless @config.respond_to?(:resolved_key_source)
+
+          @config.resolved_key_source == 'keyfile'
+        end
+
+        def load_keyfile
+          path = @config.keyfile_path
+          return unless path
+
+          @keyfile = Keyfile.new(path)
+          @keyfile.load!
+        end
+
+        def install_sighup_handler
+          Signal.trap('HUP') { @keyfile&.reload! }
+        rescue ArgumentError
+          # Signal not supported on this platform
+        end
+
+        def authenticate_api_key(env)
+          if @keyfile
+            token = extract_bearer_token(env) # gitleaks:allow
+            return unauthorized('Missing Authorization header') unless token
+
+            authenticate_via_keyfile(env, token)
+          else
+            authenticate_via_env(env)
+          end
+        end
+
+        def authenticate_via_keyfile(env, token)
+          key_entry = @keyfile.find_key(token)
+          if key_entry
+            env['rosett_ai.authenticated'] = true
+            env['rosett_ai.client_id'] = key_entry[:name]
+            SecurityLogger.auth_success(key_entry[:name])
+            @app.call(env)
+          else
+            SecurityLogger.auth_failure('invalid_key')
+            unauthorized('Invalid API key')
+          end
+        end
+
+        def authenticate_via_env(env)
+          env_var = @config.respond_to?(:api_key_env) ? @config.api_key_env : 'RAI_MCP_API_KEY'
+          expected = ENV.fetch(env_var, nil)
+
+          unless expected
+            SecurityLogger.log(:warn, 'no_api_key_configured',
+                               env_var: env_var,
+                               message: 'HTTP request received with no API key configured — running unauthenticated')
+            env['rosett_ai.authenticated'] = false
+            return @app.call(env)
+          end
+
+          token = extract_bearer_token(env) # gitleaks:allow
+          return unauthorized('Missing Authorization header') unless token
+
+          if Rack::Utils.secure_compare(token, expected)
+            env['rosett_ai.authenticated'] = true
+            env['rosett_ai.client_id'] = 'env_key'
+            SecurityLogger.auth_success('env_key')
+            @app.call(env)
+          else
+            SecurityLogger.auth_failure('invalid_env_key')
+            unauthorized('Invalid API key')
+          end
+        end
+
+        def extract_bearer_token(env)
+          auth = env['HTTP_AUTHORIZATION']
+          return nil unless auth
+
+          scheme, token = auth.split(' ', 2) # gitleaks:allow
+          return nil unless scheme&.casecmp('bearer')&.zero?
+
+          token
+        end
+
+        def unauthorized(message)
+          body = JSON.generate(
+            jsonrpc: '2.0',
+            error: { code: -32_600, message: "Unauthorized: #{message}" },
+            id: nil
+          )
+          [401, { 'content-type' => 'application/json', 'www-authenticate' => 'Bearer' }, [body]]
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/middleware/content_type.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Middleware
+      # Rack middleware that enforces application/json on POST requests.
+      #
+      # Returns 415 Unsupported Media Type for non-JSON POST bodies.
+      #
+      # @author hugo
+      # @author claude
+      class ContentType
+        # @param app [#call] the next Rack application
+        def initialize(app)
+          @app = app
+        end
+
+        # @param env [Hash] Rack environment
+        # @return [Array] Rack response triplet
+        def call(env)
+          return @app.call(env) unless post_request?(env)
+          return @app.call(env) if json_content_type?(env)
+
+          unsupported_media_type(env)
+        end
+
+        private
+
+        def post_request?(env)
+          env['REQUEST_METHOD'] == 'POST'
+        end
+
+        def json_content_type?(env)
+          content_type = env['CONTENT_TYPE'].to_s
+          content_type.start_with?('application/json')
+        end
+
+        def unsupported_media_type(env)
+          got = env['CONTENT_TYPE'].to_s
+          body = JSON.generate(
+            jsonrpc: '2.0',
+            error: {
+              code: -32_600,
+              message: "Content-Type must be application/json, got: #{got}"
+            },
+            id: nil
+          )
+          [415, { 'content-type' => 'application/json' }, [body]]
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/middleware/cors.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Middleware
+      # Rack middleware for CORS header handling and preflight.
+      #
+      # Disabled by default. When enabled, handles OPTIONS preflight
+      # and adds CORS headers to responses.
+      #
+      # @author hugo
+      # @author claude
+      class Cors
+        # @param app [#call] the next Rack application
+        # @param config [#origins, #methods, #headers, #max_age] CORS config
+        DEFAULT_METHODS = ['POST', 'GET', 'DELETE'].freeze
+        DEFAULT_HEADERS = ['Content-Type', 'Authorization', 'Accept', 'Mcp-Session-Id'].freeze
+        DEFAULT_MAX_AGE = 86_400
+        CONFIG_FIELDS = [:origins, :methods, :headers, :max_age].freeze
+
+        def initialize(app, config: nil)
+          @app = app
+          @origins = resolve_config(config, :origins, [])
+          @methods = resolve_config(config, :methods, DEFAULT_METHODS)
+          @headers = resolve_config(config, :headers, DEFAULT_HEADERS)
+          @max_age = resolve_config(config, :max_age, DEFAULT_MAX_AGE)
+        end
+
+        # @param env [Hash] Rack environment
+        # @return [Array] Rack response triplet
+        def call(env)
+          return handle_preflight(env) if preflight?(env)
+
+          status, headers, body = @app.call(env)
+          add_cors_headers(headers, env)
+          [status, headers, body]
+        end
+
+        private
+
+        def preflight?(env)
+          env['REQUEST_METHOD'] == 'OPTIONS' && env['HTTP_ORIGIN']
+        end
+
+        def handle_preflight(env)
+          origin = env['HTTP_ORIGIN']
+          return [403, {}, []] unless origin_allowed?(origin)
+
+          [204, preflight_headers(origin), []]
+        end
+
+        def preflight_headers(origin)
+          {
+            'access-control-allow-origin' => origin,
+            'access-control-allow-methods' => @methods.join(', '),
+            'access-control-allow-headers' => @headers.join(', '),
+            'access-control-max-age' => @max_age.to_s
+          }
+        end
+
+        def add_cors_headers(headers, env)
+          origin = env['HTTP_ORIGIN']
+          return unless origin && origin_allowed?(origin)
+
+          headers['access-control-allow-origin'] = origin
+        end
+
+        def origin_allowed?(origin)
+          @origins.include?(origin)
+        end
+
+        def resolve_config(config, field, default)
+          return default unless CONFIG_FIELDS.include?(field) && config.respond_to?(field)
+
+          config.public_send(field) # rubocop:disable RosettAi/UnsafeSend -- field validated against CONFIG_FIELDS allowlist
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/middleware/origin_validation.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Middleware
+      # Rack middleware that validates Origin header against an allowlist.
+      #
+      # Supports glob patterns (e.g., 'http://localhost:*').
+      # Returns 403 Forbidden for disallowed origins.
+      # Localhost-only by default.
+      #
+      # @author hugo
+      # @author claude
+      class OriginValidation
+        DEFAULT_ORIGINS = ['http://localhost:*', 'http://127.0.0.1:*'].freeze
+
+        # @param app [#call] the next Rack application
+        # @param config [#allowed_origins, #strict_mode] origin config
+        def initialize(app, config: nil)
+          @app = app
+          @allowed_origins = config.respond_to?(:allowed_origins) ? config.allowed_origins : DEFAULT_ORIGINS
+          @strict_mode = config.respond_to?(:strict_mode) ? config.strict_mode : false
+        end
+
+        # @param env [Hash] Rack environment
+        # @return [Array] Rack response triplet
+        def call(env)
+          origin = env['HTTP_ORIGIN']
+          return handle_absent_origin(env) unless origin
+          return @app.call(env) if origin_allowed?(origin)
+
+          reject_origin(origin)
+        end
+
+        private
+
+        def handle_absent_origin(env)
+          if @strict_mode
+            forbidden('Origin header required (strict mode)')
+          else
+            @app.call(env)
+          end
+        end
+
+        def origin_allowed?(origin)
+          @allowed_origins.any? { |pattern| match_origin?(pattern, origin) }
+        end
+
+        def match_origin?(pattern, origin)
+          regex = Regexp.new("\\A#{Regexp.escape(pattern).gsub('\\*', '.*')}\\z")
+          regex.match?(origin)
+        end
+
+        def reject_origin(origin)
+          SecurityLogger.origin_rejected(origin)
+          forbidden("Origin not allowed: #{origin}")
+        end
+
+        def forbidden(message)
+          body = JSON.generate(
+            jsonrpc: '2.0',
+            error: { code: -32_600, message: message },
+            id: nil
+          )
+          [403, { 'content-type' => 'application/json' }, [body]]
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/mcp/middleware/rate_limit.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Mcp
+    module Middleware
+      # Rack middleware for token bucket rate limiting.
+      #
+      # Per-IP/per-key rate limiting with separate limits for
+      # authenticated and unauthenticated requests.
+      # Returns 429 Too Many Requests when exhausted.
+      #
+      # @author hugo
+      # @author claude
+      class RateLimit
+        DEFAULT_UNAUTH_RPM = 60
+        DEFAULT_AUTH_RPM = 300
+        BUCKET_WINDOW = 60 # seconds
+        CLEANUP_INTERVAL = 100
+
+        # @param app [#call] the next Rack application
+        # @param config [#unauthenticated_rpm, #authenticated_rpm] rate config
+        def initialize(app, config: nil)
+          @app = app
+          @unauth_rpm = config.respond_to?(:unauthenticated_rpm) ? config.unauthenticated_rpm : DEFAULT_UNAUTH_RPM
+          @auth_rpm = config.respond_to?(:authenticated_rpm) ? config.authenticated_rpm : DEFAULT_AUTH_RPM
+          @buckets = {}
+          @mutex = Mutex.new
+          @request_count = 0
+        end
+
+        # @param env [Hash] Rack environment
+        # @return [Array] Rack response triplet
+        def call(env)
+          key = bucket_key(env)
+          limit = rate_limit_for(env)
+
+          if allowed?(key, limit)
+            @app.call(env)
+          else
+            SecurityLogger.rate_limited(key)
+            too_many_requests
+          end
+        end
+
+        private
+
+        def bucket_key(env)
+          parts = [env['REMOTE_ADDR'] || 'unknown']
+          parts << env['HTTP_AUTHORIZATION'] if env['HTTP_AUTHORIZATION']
+          parts << env['HTTP_MCP_SESSION_ID'] if env['HTTP_MCP_SESSION_ID']
+          parts.join(':')
+        end
+
+        def rate_limit_for(env)
+          env['rosett_ai.authenticated'] ? @auth_rpm : @unauth_rpm
+        end
+
+        def allowed?(key, limit)
+          @mutex.synchronize do
+            @request_count += 1
+            cleanup_buckets if (@request_count % CLEANUP_INTERVAL).zero?
+
+            bucket = @buckets[key] ||= { tokens: limit, last_reset: Time.now }
+            reset_bucket(bucket, limit) if bucket_expired?(bucket)
+
+            if bucket[:tokens].positive?
+              bucket[:tokens] -= 1
+              true
+            else
+              false
+            end
+          end
+        end
+
+        def bucket_expired?(bucket)
+          Time.now - bucket[:last_reset] >= BUCKET_WINDOW
+        end
+
+        def reset_bucket(bucket, limit)
+          bucket[:tokens] = limit
+          bucket[:last_reset] = Time.now
+        end
+
+        def cleanup_buckets
+          now = Time.now
+          @buckets.delete_if { |_, bucket| now - bucket[:last_reset] >= BUCKET_WINDOW * 2 }
+        end
+
+        def too_many_requests
+          body = JSON.generate(
+            jsonrpc: '2.0',
+            error: {
+              code: -32_600,
+              message: 'Too many requests'
+            },
+            id: nil
+          )
+          [429, { 'content-type' => 'application/json', 'retry-after' => '60' }, [body]]
+        end
+      end
+    end
+  end
+end