aikido-zen 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfcc07a5e3256e9d9d35f89bea1cf884d2c51bf23d497a40401f61d7335a3dbc
-  data.tar.gz: 81055a97f6a640bafb3bfd29fbc96f0c0eeb165046191bd68518109908d92817
+  metadata.gz: aa5de81052f55031065a0e154a9fe929d8928832cbaff2cad5657f0fd262a8ed
+  data.tar.gz: 0f7b951bef59f101be88141f284fda6f9786803868e3e54be84fb1f7c5a7909b
 SHA512:
-  metadata.gz: dba14387480fa74530c2120e123aa62c9e9b81054fa58149f26a5e4d6aeca4da5fc96732add6313ba02d3fecc5c6c8a587a208e47916e2a136a277159a86b429
-  data.tar.gz: 523e4fe6c7b14586a5d9e893ad51407fe6c46c52c408eea730ad8f45bab544d5861198a8e8fa5f6e6e19c69bc532bacdadcf1da4e8c74c6e89549c3f3108e68e
+  metadata.gz: 36338bd37e39be16311ead1f8caae49dc378f62b8641ee28fb0d7f264f6c3578f1a3db1291e33613e5c4ca443d5b3ba5e64babe827a6a5dcd9cc55fc1e787184
+  data.tar.gz: 31cce0645b2d3d092424c41bfccdbcc6166efb9295101074727cdc13b48a1914b2ad3c3db74010996ff2072d1b04231740ea3f90cb4b8b372201af5a4d2ed6fc

data/docs/idor-protection.md

@@ -0,0 +1,130 @@
+# IDOR Protection
+
+IDOR stands for Insecure Direct Object Reference — it's when one account can access another account's data because a query doesn't properly filter by account.
+
+If your SaaS has accounts (or organizations, workspaces, teams, ...) and uses a column like `tenant_id` to keep each account's data separate, IDOR protection ensures every SQL query filters on the correct tenant. Zen analyzes queries at runtime and raises an error if a query is missing that filter or uses the wrong tenant ID, catching mistakes like:
+
+- A `SELECT` that forgets the tenant filter, letting one account read another's orders
+- An `UPDATE` or `DELETE` without a tenant filter, letting one account modify another's data
+- An `INSERT` that omits the tenant column, creating orphaned or misassigned rows
+
+Zen catches these at runtime so they surface during development and testing, not in production. See [IDOR vulnerability explained](https://www.aikido.dev/blog/idor-vulnerability-explained) for more background.
+
+> [!IMPORTANT]
+> IDOR protection always raises an `Aikido::Zen::IDOR::Error` on violations regardless of block/detect mode. A missing filter is a developer bug, not an external attack.
+
+## Setup
+
+### 1. Enable IDOR protection at startup
+
+```ruby
+...
+
+Aikido::Zen.config.idor_protection_enabled = true
+Aikido::Zen.config.idor_tenant_column_name = "tenant_id"
+Aikido::Zen.config.idor_excluded_table_names = ["users"]
+
+...
+```
+
+- `idor_tenant_column_name` — the column name that identifies the tenant in your database tables (e.g. `account_id`, `organization_id`, `team_id`).
+- `idor_excluded_table_names` — tables that Zen should skip IDOR checks for, because rows aren't scoped to a single tenant (e.g. a shared `users` table that stores users across all tenants).
+
+### 2. Set the tenant ID per request
+
+Every request must have a tenant ID when IDOR protection is enabled. Call `Aikido::Zen.set_tenant_id` early in your request handler (e.g. in middleware after authentication):
+
+```ruby
+Aikido::Zen.set_tenant_id(1)
+```
+
+> [!IMPORTANT]
+> If `Aikido::Zen.set_tenant_id` is not called for a request, Zen will raise an `Aikido::Zen::IDOR::Error` when a SQL query is executed.
+
+### 3. Bypass for specific queries (optional)
+
+Some queries don't need tenant filtering (e.g. aggregations across all tenants for an admin dashboard). Use `Aikido::Zen.without_idor_protection` to bypass the check for a specific block:
+
+```ruby
+...
+
+# IDOR checks are skipped for queries inside this block
+result = Aikido::Zen.without_idor_protection do
+  db.execute("SELECT count(*) FROM agents WHERE status = 'running'");
+end
+
+...
+```
+
+## Troubleshooting
+
+<details>
+<summary>Missing tenant filter</summary>
+
+```
+Zen IDOR protection: query on table 'orders' is missing a filter on column 'tenant_id'
+```
+
+This means you have a query like `SELECT * FROM orders WHERE status = 'active'` that doesn't filter on `tenant_id`. The same check applies to `UPDATE` and `DELETE` queries.
+
+</details>
+
+<details>
+<summary>Wrong tenant ID value</summary>
+
+```
+Zen IDOR protection: query on table 'orders' filters 'tenant_id' with value '456' but tenant ID is '123'
+```
+
+This means the query filters on `tenant_id`, but the value doesn't match the tenant ID set via `Aikido::Zen.set_tenant_id`.
+
+</details>
+
+<details>
+<summary>Missing tenant column in INSERT</summary>
+
+```
+Zen IDOR protection: INSERT on table 'orders' is missing column 'tenant_id'
+```
+
+This means an `INSERT` statement doesn't include the tenant column. Every INSERT must include the tenant column with the correct tenant ID value.
+
+</details>
+
+<details>
+<summary>Wrong tenant ID in INSERT</summary>
+
+```
+Zen IDOR protection: INSERT on table 'orders' sets 'tenant_id' to '456' but tenant ID is '123'
+```
+
+This means the INSERT includes the tenant column, but the value doesn't match the tenant ID set via `Aikido::Zen.set_tenant_id`.
+
+</details>
+
+<details>
+<summary>Missing Aikido::Zen.set_tenant_id call</summary>
+
+```
+Zen IDOR protection: Aikido::Zen.set_tenant_id was not called for this request. Every request must have a tenant ID when IDOR protection is enabled.
+```
+
+</details>
+
+## Supported databases
+
+- SQLite (via `sqlite3` Gem)
+- PostgreSQL (via `pg` Gem)
+- MySQL (via `mysql2` and `trilogy` Gems)
+
+Any ORM or query builder that uses these database packages under the hood is supported (e.g. ActiveRecord). ORMs that use their own database engine are not supported unless configured to use a supported driver adapter.
+
+## Limitations
+
+## Statements that are always allowed
+
+Zen only checks statements that read or modify row data (`SELECT`, `INSERT`, `UPDATE`, `DELETE`). The following statement types are also recognized and never trigger an IDOR error:
+
+- DDL — `CREATE TABLE`, `ALTER TABLE`, `DROP TABLE`, ...
+- Session commands — `SET`, `SHOW`, ...
+- Transactions — `BEGIN`, `COMMIT`, `ROLLBACK`, ...

data/lib/aikido/zen/config.rb

@@ -199,6 +199,23 @@ module Aikido::Zen
     #  Defaults to 1.0 seconds.
     attr_accessor :redos_regexp_timeout
 
+    # @return [Boolean] whether the IDOR protection feature is enabled.
+    #   Defaults to false.
+    attr_accessor :idor_protection_enabled
+    alias_method :idor_protection_enabled?, :idor_protection_enabled
+
+    # @return [String] the tenant column name for IDOR protection.
+    #   Defaults to nil.
+    attr_accessor :idor_tenant_column_name
+
+    # @return [Array<String>] the table names to exclude for IDOR protection.
+    #   Defaults to [].
+    attr_accessor :idor_excluded_table_names
+
+    # @return [Integer] the maximum number of entries in the LRU cache.
+    #   Defaults to 1000 entries.
+    attr_accessor :idor_max_cache_entries
+
     def initialize
       self.insert_middleware_after = ::ActionDispatch::RemoteIp
       self.disabled = read_boolean_from_env(ENV.fetch("AIKIDO_DISABLE", false)) || read_boolean_from_env(ENV.fetch("AIKIDO_DISABLED", false))
@@ -240,6 +257,10 @@ module Aikido::Zen
       self.attack_wave_max_cache_entries = 10_000
       self.attack_wave_max_cache_samples = 15
       self.redos_regexp_timeout = 1.0
+      self.idor_protection_enabled = false
+      self.idor_tenant_column_name = nil
+      self.idor_excluded_table_names = []
+      self.idor_max_cache_entries = 1000
     end
 
     # Set the base URL for API requests.

data/lib/aikido/zen/context.rb

@@ -30,6 +30,10 @@ module Aikido::Zen
     attr_accessor :protection_disabled
     alias_method :protection_disabled?, :protection_disabled
 
+    # @return [Boolean]
+    attr_accessor :idor_protection_enabled
+    alias_method :idor_protection_enabled?, :idor_protection_enabled
+
     # @param request [Rack::Request] a Request object that implements the
     #   Rack::Request API, to which we will delegate behavior.
     # @param settings [Aikido::Zen::RuntimeSettings]
@@ -45,6 +49,7 @@ module Aikido::Zen
       @metadata = {}
       @scanning = false
       @protection_disabled = false
+      @idor_protection_enabled = false
     end
 
     # Fetch some metadata stored in the Context.

data/lib/aikido/zen/idor/analysis_result.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Aikido::Zen
+  module IDOR
+    class Table
+      def self.from_json(data)
+        new(
+          name: data["name"],
+          alt_name: data["alias"]
+        )
+      end
+
+      # @param name [String]
+      # @param alt_name [String, nil]
+      def initialize(name:, alt_name: nil)
+        @name = name
+        @alt_name = alt_name
+      end
+
+      # @return [String]
+      attr_accessor :name
+      # @return [String, nil]
+      attr_accessor :alt_name
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.name == name &&
+          other.alt_name == alt_name
+      end
+      alias_method :eql?, :==
+    end
+
+    class FilterColumn
+      def self.from_json(data)
+        new(
+          table_qualifier: data["table"],
+          name: data["column"],
+          value: data["value"],
+          is_placeholder: data["is_placeholder"],
+          placeholder_number: data["placeholder_number"]
+        )
+      end
+
+      # @param table_qualifier [String, nil]
+      # @param name [String]
+      # @param value [String]
+      # @param is_placeholder [Boolean]
+      # @param placeholder_number [Integer, nil]
+      def initialize(table_qualifier:, name:, value:, is_placeholder:, placeholder_number: nil)
+        @table_qualifier = table_qualifier
+        @name = name
+        @value = value
+        @is_placeholder = is_placeholder
+        @placeholder_number = placeholder_number
+      end
+
+      # @return [String, nil]
+      attr_accessor :table_qualifier
+
+      # @return [String]
+      attr_accessor :name
+
+      # @return [String]
+      attr_accessor :value
+
+      # @return [Boolean]
+      attr_accessor :is_placeholder
+
+      # @return [Integer, nil]
+      attr_accessor :placeholder_number
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.table_qualifier == table_qualifier &&
+          other.name == name &&
+          other.value == value &&
+          other.is_placeholder == is_placeholder &&
+          other.placeholder_number == placeholder_number
+      end
+      alias_method :eql?, :==
+    end
+
+    class InsertColumn
+      def self.from_json(data)
+        new(
+          name: data["column"],
+          value: data["value"],
+          is_placeholder: data["is_placeholder"],
+          placeholder_number: data["placeholder_number"]
+        )
+      end
+
+      # @param name [String]
+      # @param value [String]
+      # @param is_placeholder [Boolean]
+      # @param placeholder_number [Integer, nil]
+      def initialize(name:, value:, is_placeholder:, placeholder_number: nil)
+        @name = name
+        @value = value
+        @is_placeholder = is_placeholder
+        @placeholder_number = placeholder_number
+      end
+
+      # @return [String]
+      attr_accessor :name
+
+      # @return [String]
+      attr_accessor :value
+
+      # @return [Boolean]
+      attr_accessor :is_placeholder
+
+      # @return [Integer, nil]
+      attr_accessor :placeholder_number
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.name == name &&
+          other.value == value &&
+          other.is_placeholder == is_placeholder &&
+          other.placeholder_number == placeholder_number
+      end
+      alias_method :eql?, :==
+    end
+
+    class SQLQueryResult
+      def self.from_json(data)
+        new(
+          kind: data["kind"].to_sym,
+          tables: data["tables"].map { |value| Table.from_json(value) },
+          filter_columns: data["filters"].map { |value| FilterColumn.from_json(value) },
+          insert_columns: data["insert_columns"]&.map do |values|
+            values.map { |value| InsertColumn.from_json(value) }
+          end
+        )
+      end
+
+      # @param kind [:select, :insert, :update, :delete]
+      # @param tables [Array<Aikido::Zen::IDOR::Table>]
+      # @param filter_columns [Array<Aikido::Zen::IDOR::FilterColumn>]
+      # @param insert_columns [Array<Array<Aikido::Zen::IDOR::InsertColumn>>, nil]
+      def initialize(kind:, tables:, filter_columns:, insert_columns: nil)
+        raise ArgumentError, "kind must be one of :select, :insert, :update, or :delete" unless [:select, :insert, :update, :delete].include?(kind)
+
+        @kind = kind
+        @tables = tables
+        @filter_columns = filter_columns
+        @insert_columns = insert_columns
+      end
+
+      # @return [:select, :insert, :update, :delete]
+      attr_accessor :kind
+
+      # @return [Array<Aikido::Zen::IDOR::Table>]
+      attr_accessor :tables
+
+      # @return [Array<Aikido::Zen::IDOR::FilterColumn>]
+      attr_accessor :filter_columns
+
+      # @return [Array<Array<Aikido::Zen::IDOR::InsertColumn>>, nil]
+      attr_accessor :insert_columns
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.kind == kind &&
+          other.tables == tables &&
+          other.filter_columns == filter_columns &&
+          other.insert_columns == insert_columns
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

data/lib/aikido/zen/idor/protector.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Aikido::Zen
+  module IDOR
+    class Error < StandardError
+    end
+
+    class Protector
+      # @api private
+      # Visible for testing.
+      attr_accessor :cache
+
+      def initialize(config: Aikido::Zen.config)
+        @config = config
+
+        @cache = CappedMap.new(@config.idor_max_cache_entries, mode: :lru)
+      end
+
+      # @param sql [String]
+      # @param dialect_name [Symbol]
+      # @param params [Array, nil]
+      # @param context [Aikido::Zen::Context]
+      # @raise [Aikido::Zen::IDOR::Error, Aikido::Zen::InternalsError]
+      def protect(sql, dialect_name, params, context)
+        return unless @config.idor_protection_enabled? && context.idor_protection_enabled?
+
+        tenant_id = context.request.tenant_id
+
+        if tenant_id.nil?
+          raise Aikido::Zen::IDOR::Error.new("Zen IDOR protection: Aikido::Zen.set_tenant_id was not called for this request. Every request must have a tenant ID when IDOR protection is enabled.")
+        end
+
+        dialect = Aikido::Zen::SQL::Dialects.fetch(dialect_name)
+
+        analysis = analyze(sql, dialect)
+
+        analysis.each do |query_result|
+          if query_result.kind == :insert
+            protect_insert(dialect, query_result, tenant_id, params)
+          else
+            protect_filter(dialect, query_result, tenant_id, params)
+          end
+        end
+      end
+
+      private
+
+      # @param sql [String]
+      # @param dialect [Aikido::Zen::SQL::Dialects::Dialect]
+      # @return [Array<Aikido::Zen::IDOR::SQLQueryResult>]
+      # @raise [Aikido::Zen::IDOR::Error, Aikido::Zen::InternalsError]
+      def analyze(sql, dialect)
+        cache_key = [dialect.internals_key, sql]
+
+        analysis = @cache[cache_key]
+        return analysis if analysis
+
+        analysis = Internals.idor_analyze_sql(sql, dialect)
+
+        # :nocov:
+        unless analysis
+          raise IDOR::Error, "Zen IDOR protection: failed to analyze SQL query"
+        end
+        # :nocov:
+
+        if analysis.is_a?(Hash) && analysis["error"]
+          raise IDOR::Error, "Zen IDOR protection: #{analysis["error"]}"
+        end
+
+        result = analysis.map do |value|
+          Aikido::Zen::IDOR::SQLQueryResult.from_json(value)
+        end
+
+        @cache[cache_key] = result
+
+        result
+      end
+
+      def protect_insert(dialect, query_result, tenant_id, params)
+        query_result.tables.each do |table|
+          next if @config.idor_excluded_table_names.include?(table.name)
+
+          unless query_result.insert_columns
+            # INSERT ... SELECT without explicit columns — can't verify tenant column
+            raise IDOR::Error, "Zen IDOR protection: INSERT on table '#{table.name}' is missing column '#{@config.idor_tenant_column_name}'"
+          end
+
+          query_result.insert_columns.each do |row|
+            tenant_column = row.find { |column| column.name == @config.idor_tenant_column_name }
+
+            unless tenant_column
+              raise IDOR::Error, "Zen IDOR protection: INSERT on table '#{table.name}' is missing column '#{@config.idor_tenant_column_name}'"
+            end
+
+            resolved_tenant_id = tenant_column.value
+
+            if tenant_column.is_placeholder
+              resolved_tenant_id = dialect.resolve_placeholder(tenant_column.value, tenant_column.placeholder_number, params)
+
+              unless resolved_tenant_id
+                raise IDOR::Error, "Zen IDOR protection: INSERT on table '#{table.name}' has a placeholder for '#{@config.idor_tenant_column_name}' that could not be resolved"
+              end
+            end
+
+            if resolved_tenant_id.to_s != tenant_id.to_s
+              raise IDOR::Error, "Zen IDOR protection: INSERT on table '#{table.name}' sets '#{@config.idor_tenant_column_name}' to '#{resolved_tenant_id}' but tenant ID is '#{tenant_id}'"
+            end
+          end
+        end
+      end
+
+      def protect_filter(dialect, query_result, tenant_id, params)
+        query_result.tables.each do |table|
+          next if @config.idor_excluded_table_names.include?(table.name)
+
+          tenant_column = query_result.filter_columns.find do |column|
+            next false if column.name != @config.idor_tenant_column_name
+
+            next column.table_qualifier == table.name || column.table_qualifier == table.alt_name if column.table_qualifier
+
+            # Unqualified column (e.g. WHERE tenant_id = $1 without table prefix):
+            # We can only safely attribute it to the current table when there's
+            # exactly one table in the query. With multiple tables, we can't know
+            # which table the unqualified column belongs to.
+            query_result.tables.size == 1
+          end
+
+          unless tenant_column
+            raise IDOR::Error, "Zen IDOR protection: query on table '#{table.name}' is missing column '#{@config.idor_tenant_column_name}'"
+          end
+
+          resolved_tenant_id = tenant_column.value
+
+          if tenant_column.is_placeholder
+            resolved_tenant_id = dialect.resolve_placeholder(tenant_column.value, tenant_column.placeholder_number, params)
+
+            unless resolved_tenant_id
+              raise IDOR::Error, "Zen IDOR protection: query on table '#{table.name}' has a placeholder for '#{@config.idor_tenant_column_name}' that could not be resolved"
+            end
+          end
+
+          if resolved_tenant_id.to_s != tenant_id.to_s
+            raise IDOR::Error, "Zen IDOR protection: query on table '#{table.name}' sets '#{@config.idor_tenant_column_name}' to '#{resolved_tenant_id}' but tenant ID is '#{tenant_id}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aikido/zen/idor.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "idor/analysis_result"
+require_relative "idor/protector"

data/lib/aikido/zen/internals.rb

@@ -26,10 +26,12 @@ module Aikido::Zen
 
       names << "#{lib_name}-#{platform}.#{lib_ext}"
 
+      # :nocov:
       unless platform.version.nil?
         platform.version = nil
         names << "#{lib_name}-#{platform}.#{lib_ext}"
       end
+      # :nocov:
 
       names
     end
@@ -51,7 +53,9 @@ module Aikido::Zen
           # empty
         end
       end
+      # :nocov:
       raise LoadError, "Zen could not load its native extension #{libzen_name}"
+      # :nocov:
     end
 
     begin
@@ -59,12 +63,16 @@ module Aikido::Zen
 
       # @!method self.detect_sql_injection_native(query, input, dialect)
       # @param (see .detect_sql_injection)
-      # @returns [Integer] 0 if no injection detected, 1 if an injection was
+      # @return [Integer] 0 if no injection detected, 1 if an injection was
       #   detected, 2 if there was an internal error, or 3 if SQL tokenization failed.
       # @raise [Aikido::Zen::InternalsError] if there's a problem loading or
       #   calling libzen.
       attach_function :detect_sql_injection_native, :detect_sql_injection,
         [:pointer, :size_t, :pointer, :size_t, :int], :int
+
+      attach_function :idor_analyze_sql_native, :idor_analyze_sql_ffi, [:pointer, :size_t, :int], :pointer
+
+      attach_function :idor_free_string_native, :free_string, [:pointer], :void
     rescue LoadError, FFI::NotFoundError => err # rubocop:disable Lint/ShadowedException
       # :nocov:
 
@@ -76,6 +84,11 @@ module Aikido::Zen
         raise InternalsError.new(attempt, "loading", libzen_name)
       end
 
+      def self.idor_analyze_sql(query, *)
+        attempt = format("%p for SQL analysis", query)
+        raise InternalsError.new(attempt, "loading", libzen_name)
+      end
+
       # :nocov:
     else
       # Analyzes the SQL query to detect if the provided user input is being
@@ -86,7 +99,7 @@ module Aikido::Zen
       # @param dialect [Integer, #to_int] the SQL Dialect identifier in libzen.
       #   See {Aikido::Zen::Scanners::SQLInjectionScanner::DIALECTS}.
       #
-      # @returns [Boolean]
+      # @return [Boolean]
       # @raise [Aikido::Zen::InternalsError] if there's a problem loading or
       #   calling libzen.
       def self.detect_sql_injection(query, input, dialect)
@@ -108,6 +121,18 @@ module Aikido::Zen
 
         result
       end
+
+      def self.idor_analyze_sql(query, dialect)
+        query_bytes = encode_safely(query)
+        query_ptr = FFI::MemoryPointer.new(:uint8, query_bytes.bytesize)
+        query_ptr.put_bytes(0, query_bytes)
+
+        result_ptr = idor_analyze_sql_native(query_ptr, query_bytes.bytesize, dialect)
+        result_json = result_ptr.read_string
+        idor_free_string_native(result_ptr)
+
+        JSON.parse(result_json)
+      end
     end
 
     class << self

data/lib/aikido/zen/rails_engine.rb

@@ -39,6 +39,10 @@ module Aikido::Zen
       end
 
       ActiveSupport.on_load(:action_controller) do
+        before_action do
+          Aikido::Zen.enable_idor_protection if Aikido::Zen.config.idor_protection_enabled?
+        end
+
         # Due to how Rails sets up its middleware chain, the routing is evaluated
         # (and the Request object constructed) in the app that terminates the
         # chain, so no amount of middleware will be able to access it.

data/lib/aikido/zen/request.rb

@@ -17,6 +17,12 @@ module Aikido::Zen
     # @see Aikido::Zen.track_user
     attr_accessor :actor
 
+    # The current tenant, if set by the host app.
+    #
+    # @return [Integer, String, nil]
+    # @see Aikido::Zen.set_tenant_id
+    attr_accessor :tenant_id
+
     def initialize(delegate, config = Aikido::Zen.config, framework:, router:)
       super(delegate)
       @config = config

data/lib/aikido/zen/scanners/sql_injection_scanner.rb

@@ -24,10 +24,7 @@ module Aikido::Zen
       # @return [Aikido::Zen::Attack, nil] an Attack if any user input is
       #   detected to be attempting a SQL injection, or nil if this is safe.
       def self.call(query:, dialect:, scan:, sink:, context:, operation:)
-        dialect = DIALECTS.fetch(dialect) do
-          Aikido::Zen.config.logger.warn "Unknown SQL dialect #{dialect.inspect}"
-          DIALECTS[:common]
-        end
+        dialect = Aikido::Zen::SQL::Dialects.fetch(dialect)
 
         context.payloads.each do |payload|
           scanner = new(query, payload.value.to_s, dialect)
@@ -93,23 +90,6 @@ module Aikido::Zen
 
         raise err
       end
-
-      # @api private
-      Dialect = Struct.new(:name, :internals_key, keyword_init: true) do
-        alias_method :to_s, :name
-        alias_method :to_int, :internals_key
-      end
-
-      # Maps easy-to-use Symbols to a struct that keeps both the name and the
-      # internal identifier used by libzen.
-      #
-      # @see https://github.com/AikidoSec/zen-internals/blob/main/src/sql_injection/helpers/select_dialect_based_on_enum.rs
-      DIALECTS = {
-        common: Dialect.new(name: "SQL", internals_key: 0),
-        mysql: Dialect.new(name: "MySQL", internals_key: 8),
-        postgresql: Dialect.new(name: "PostgreSQL", internals_key: 9),
-        sqlite: Dialect.new(name: "SQLite", internals_key: 12)
-      }
     end
   end
 end

data/lib/aikido/zen/sinks/mysql2.rb

@@ -18,8 +18,32 @@ module Aikido::Zen
           ::Mysql2::Client.class_eval do
             extend Sinks::DSL
 
-            sink_before :query do |sql|
-              Helpers.scan(sql, "query")
+            presafe_sink_before :query do |sql|
+              Sinks::DSL.safe do
+                Helpers.scan(sql, "query")
+              end
+
+              Aikido::Zen.idor_protect(sql, :mysql)
+            end
+
+            presafe_sink_after :prepare do |result, sql|
+              result.aikido_idor_sql = sql
+            end
+          end
+
+          ::Mysql2::Statement.class_eval do
+            extend Sinks::DSL
+
+            attr_accessor :aikido_idor_sql
+
+            presafe_sink_before :execute do |*args, **kwargs|
+              sql = aikido_idor_sql
+
+              Sinks::DSL.safe do
+                Helpers.scan(sql, "query")
+              end
+
+              Aikido::Zen.idor_protect(sql, :mysql, args)
             end
           end
         end

data/lib/aikido/zen/sinks/pg.rb

@@ -44,31 +44,63 @@ module Aikido::Zen
 
             [
               :send_query,
-              :exec,
-              :sync_exec,
+              :exec, # also known as: async_exec
               :async_exec,
+              :sync_exec
+            ].each do |method_name|
+              presafe_sink_before method_name do |sql|
+                Helpers.safe do
+                  Helpers.scan(sql, method_name)
+                end
+
+                Aikido::Zen.idor_protect(sql, :postgresql)
+              end
+            end
+
+            [
               :send_query_params,
-              :exec_params,
-              :sync_exec_params,
-              :async_exec_params
+              :exec_params, # also known as: async_exec_params
+              :async_exec_params,
+              :sync_exec_params
             ].each do |method_name|
-              presafe_sink_before method_name do |query|
+              presafe_sink_before method_name do |sql, params|
                 Helpers.safe do
-                  Helpers.scan(query, method_name)
+                  Helpers.scan(sql, method_name)
                 end
+
+                Aikido::Zen.idor_protect(sql, :postgresql, params)
               end
             end
 
+            def aikido_idor_prepared_statements
+              @aikido_idor_prepared_statements ||= {}
+            end
+
             [
               :send_prepare,
-              :prepare,
+              :prepare, # also known as: async_prepare
               :async_prepare,
               :sync_prepare
             ].each do |method_name|
-              presafe_sink_before method_name do |_, query|
+              presafe_sink_before method_name do |statement_name, sql|
+                aikido_idor_prepared_statements[statement_name] = sql
+              end
+            end
+
+            [
+              :send_query_prepared,
+              :exec_prepared, # also known as: async_exec_prepared
+              :async_exec_prepared,
+              :sync_exec_prepared
+            ].each do |method_name|
+              presafe_sink_before method_name do |statement_name, params|
+                sql = aikido_idor_prepared_statements[statement_name]
+
                 Helpers.safe do
-                  Helpers.scan(query, method_name)
+                  Helpers.scan(sql, method_name)
                 end
+
+                Aikido::Zen.idor_protect(sql, :postgresql, params)
               end
             end
           end

data/lib/aikido/zen/sinks/sqlite3.rb

@@ -22,19 +22,63 @@ module Aikido::Zen
           ::SQLite3::Database.class_eval do
             extend Sinks::DSL
 
-            private
+            [
+              :execute,
+              :execute_batch
+            ].each do |method_name|
+              presafe_sink_before method_name do |sql, bind_vars|
+                Sinks::DSL.safe do
+                  Helpers.scan(sql, "database.execute")
+                end
+
+                Aikido::Zen.idor_protect(sql, :sqlite, bind_vars)
+              end
+            end
 
             # SQLite3::Database#exec_batch is an internal native private method.
-            sink_before :exec_batch do |sql|
-              Helpers.scan(sql, "exec_batch")
+            presafe_sink_before :exec_batch do |sql, *args, **kwargs|
+              Sinks::DSL.safe do
+                Helpers.scan(sql, "exec_batch")
+              end
+
+              Aikido::Zen.idor_protect(sql, :sqlite)
+            end
+
+            alias_method :prepare__internal_for_aikido_zen, :prepare
+
+            def prepare(*args, **kwargs, &blk)
+              sql, = args
+
+              Sinks::DSL.safe do
+                Helpers.scan(sql, "statement.execute")
+              end
+
+              unless blk
+                result = prepare__internal_for_aikido_zen(*args, **kwargs)
+                result.aikido_idor_sql = sql
+                return result
+              end
+
+              prepare__internal_for_aikido_zen(*args, **kwargs) do |stmt|
+                stmt.aikido_idor_sql = sql
+                blk.call(stmt)
+              end
             end
           end
 
           ::SQLite3::Statement.class_eval do
             extend Sinks::DSL
 
-            sink_before :initialize do |_db, sql|
-              Helpers.scan(sql, "statement.execute")
+            attr_accessor :aikido_idor_sql
+
+            presafe_sink_before :execute do |*bind_vars|
+              sql = aikido_idor_sql
+
+              Sinks::DSL.safe do
+                Helpers.scan(sql, "statement.execute")
+              end
+
+              Aikido::Zen.idor_protect(sql, :sqlite, bind_vars)
             end
           end
         end

data/lib/aikido/zen/sinks/trilogy.rb

@@ -18,8 +18,12 @@ module Aikido::Zen
           ::Trilogy.class_eval do
             extend Sinks::DSL
 
-            sink_before :query do |query|
-              Helpers.scan(query, "query")
+            presafe_sink_before :query do |sql|
+              Sinks::DSL.safe do
+                Helpers.scan(sql, "query")
+              end
+
+              Aikido::Zen.idor_protect(sql, :mysql)
             end
           end
         end

data/lib/aikido/zen/sql.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Aikido::Zen
+  module SQL
+    module Dialects
+      # @api private
+      Dialect = Struct.new(:name, :internals_key, :placeholder_resolver, keyword_init: true) do
+        alias_method :to_s, :name
+        alias_method :to_int, :internals_key
+
+        def resolve_placeholder(*args, **kwargs)
+          placeholder_resolver.call(*args, **kwargs)
+        end
+      end
+
+      # @param value [String]
+      # @param placeholder_number [Integer, nil]
+      # @param params [Array<Object>, nil]
+      # @return [Object]
+      def self.common_placeholder_resolver(value, placeholder_number, params)
+        return nil unless params
+
+        params[placeholder_number] unless placeholder_number.nil?
+      end
+
+      # @param value [String]
+      # @param placeholder_number [Integer, nil]
+      # @param params [Array<Object>, nil]
+      # @return [Object]
+      def self.postgresql_placeholder_resolver(value, placeholder_number, params)
+        return nil unless params
+
+        match = value.match(/^\$(\d+)$/)
+        if match
+          index = match[1].to_i - 1
+          return if index < 0
+
+          params[index]
+        end
+      end
+
+      # @param value [String]
+      # @param placeholder_number [Integer, nil]
+      # @param params [Array<Object>, nil]
+      # @return [Object]
+      def self.sqlite_placeholder_resolver(value, placeholder_number, params)
+        return nil unless params
+
+        return params[placeholder_number] unless placeholder_number.nil?
+
+        case value
+        when /^\?(\d+)$/
+          match = Regexp.last_match
+
+          index = match[1].to_i - 1
+          return if index < 0
+
+          params[index]
+        when /^[:@$]([A-Za-z_][A-Za-z0-9_]*)$/
+          match = Regexp.last_match
+
+          key = match[1]
+
+          params.flatten.each do |param|
+            if Hash === param
+              param.each do |param_key, param_value|
+                return param_value if param_key.to_s == key
+              end
+            end
+          end
+        end
+      end
+
+      # Maps easy-to-use Symbols to a struct that keeps both the name and the
+      # internal identifier used by libzen.
+      #
+      # @see https://github.com/AikidoSec/zen-internals/blob/main/src/sql_injection/helpers/select_dialect_based_on_enum.rs
+      DIALECTS = {
+        common: Dialect.new(
+          name: "SQL",
+          internals_key: 0,
+          placeholder_resolver: method(:common_placeholder_resolver)
+        ),
+        mysql: Dialect.new(
+          name: "MySQL",
+          internals_key: 8,
+          placeholder_resolver: method(:common_placeholder_resolver)
+        ),
+        postgresql: Dialect.new(
+          name: "PostgreSQL",
+          internals_key: 9,
+          placeholder_resolver: method(:postgresql_placeholder_resolver)
+        ),
+        sqlite: Dialect.new(
+          name: "SQLite",
+          internals_key: 12,
+          placeholder_resolver: method(:sqlite_placeholder_resolver)
+        )
+      }.freeze
+
+      # @param dialect [Symbol]
+      # @return [Aikido::Zen::SQL::Dialects::Dialect]
+      def self.fetch(dialect)
+        DIALECTS.fetch(dialect, DIALECTS[:common])
+      end
+    end
+  end
+end

data/lib/aikido/zen/version.rb

@@ -2,9 +2,9 @@
 
 module Aikido
   module Zen
-    VERSION = "1.3.1"
+    VERSION = "1.4.0"
 
     # The version of libzen_internals that we build against.
-    LIBZEN_VERSION = "0.1.60"
+    LIBZEN_VERSION = "0.1.61"
   end
 end

data/lib/aikido/zen.rb

@@ -26,6 +26,8 @@ require_relative "zen/outbound_connection"
 require_relative "zen/runtime_settings"
 require_relative "zen/rate_limiter"
 require_relative "zen/attack_wave"
+require_relative "zen/sql"
+require_relative "zen/idor"
 require_relative "zen/scanners"
 
 module Aikido
@@ -213,17 +215,78 @@ module Aikido
       alias_method :set_user, :track_user
     end
 
+    # @return [Aikido::Zen::AttackWave::Detector] the attack wave detector.
+    def self.attack_wave_detector
+      @attack_wave_detector ||= AttackWave::Detector.new
+    end
+
+    # @return [Aikido::Zen::IDOR::Protector]
+    def self.idor_protector
+      @idor_protector ||= IDOR::Protector.new
+    end
+
+    # @param sql [String]
+    # @param dialect [Symbol]
+    # @param params [Array, nil]
+    # @return [void]
+    # @raise [Aikido::Zen::IDOR::Error]
+    def self.idor_protect(sql, dialect_name, params = nil)
+      context = current_context
+      return unless context
+
+      idor_protector.protect(sql, dialect_name, params, context)
+    end
+
+    # Enable IDOR protection for the current context.
+    #
+    # @return [void]
+    def self.enable_idor_protection
+      context = current_context
+      return unless context
+
+      context.idor_protection_enabled = true
+    end
+
+    # Set the tenant ID for the current request.
+    #
+    # @param tenant_id [Integer, String, nil]
+    # @return [void]
+    def self.set_tenant_id(tenant_id)
+      context = current_context
+      return unless context
+
+      context.request.tenant_id = tenant_id
+    end
+
+    # Execute a block with the IDOR protection disabled.
+    #
+    # @yield the block to execute with the IDOR protection disabled.
+    # @return [Object] the result of the block
+    # @raise [ArgumentError] if no block is given
+    def self.without_idor_protection
+      raise ArgumentError, "block required" unless block_given?
+
+      context = current_context
+
+      if context
+        begin
+          original_idor_protection_enabled = context.idor_protection_enabled
+          context.idor_protection_enabled = false
+          yield
+        ensure
+          context.idor_protection_enabled = original_idor_protection_enabled
+        end
+      else
+        yield
+      end
+    end
+
     # Marks that the Zen middleware was installed properly
     # @return void
     def self.middleware_installed!
       collector.middleware_installed!
     end
 
-    # @return [Aikido::Zen::AttackWave::Detector] the attack wave detector.
-    def self.attack_wave_detector
-      @attack_wave_detector ||= AttackWave::Detector.new
-    end
-
     # @!visibility private
     # Load all sources.
     #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aikido-zen
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Aikido Security
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-07 00:00:00.000000000 Z
+date: 2026-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -87,6 +87,7 @@ files:
 - benchmarks/rails7.1_sql_injection.js
 - docs/banner.svg
 - docs/config.md
+- docs/idor-protection.md
 - docs/invalid-sql-queries.md
 - docs/proxy.md
 - docs/rails.md
@@ -122,6 +123,9 @@ files:
 - lib/aikido/zen/errors.rb
 - lib/aikido/zen/event.rb
 - lib/aikido/zen/helpers.rb
+- lib/aikido/zen/idor.rb
+- lib/aikido/zen/idor/analysis_result.rb
+- lib/aikido/zen/idor/protector.rb
 - lib/aikido/zen/internals.rb
 - lib/aikido/zen/middleware/allowed_address_checker.rb
 - lib/aikido/zen/middleware/attack_protector.rb
@@ -192,6 +196,7 @@ files:
 - lib/aikido/zen/sinks/trilogy.rb
 - lib/aikido/zen/sinks/typhoeus.rb
 - lib/aikido/zen/sinks_dsl.rb
+- lib/aikido/zen/sql.rb
 - lib/aikido/zen/synchronizable.rb
 - lib/aikido/zen/system_info.rb
 - lib/aikido/zen/version.rb