libddwaf 1.24.1.0.0-aarch64-linux-gnu

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8a653e524afde6fdc6f9e3a9db812fda40cd9e3a964e6f67b123760efd4d358c
+  data.tar.gz: a092610161c737ed19cc587b8734003dfbe403b3d74dae7f1936b539b6deaa99
+SHA512:
+  metadata.gz: d9a6b8647b77c7a559b7247663039fad1ed0b6bba261c85462922322e2cf47c9d8313e22d523bfbaa9c0f774a89b4ba8e3639b0c7a6cc2faa8d6b8a7400f2d85
+  data.tar.gz: 3f2176f52fae27e6d5a11e39a98fdeab21bacbcbef25cadf953f96c4d8297f68c0b7276f2a6d766de2161bddfc716965d077479ef02970bfe9b36f0d3e35606f

data/CHANGELOG.md

@@ -0,0 +1,153 @@
+# Unreleased v1.23.0.0.0
+
+## Added
+
+- Add `HandleBuilder` class for managing libddwaf configuration and building WAF handles
+- Add Error classes:
+  - `LibDDWAFError` for libddwaf errors
+  - `ConversionError` for conversion errors
+  - `InstanceFinalizedError` that is raised when attempting to run methods on finalized instances
+
+## Changed
+
+- Change `Handle` instantiation - now it should be done using `HandleBuilder#build_handle` method
+- Change `Context` instantiation - now is should be done using `Handle#build_context` method
+- Change configuration of Limits and obfuscation - it is now done when initializing `HandleBuilder`
+- Change `Context#run` to return a `Result` object instead of an tuple with code and result
+
+## Removed
+
+- Remove `WAF::Handle#merge` method - the configuration is now handled by `HandleBuilder`
+
+# 2025-02-20 v.1.18.0.0.1
+
+- Fixed memory-leak in `Datadog::AppSec::WAF::Context#run` when non-empty ephemeral data passed
+
+# 2024-10-29 v.1.15.0.0.0
+
+- Update to libddwaf 1.15.0
+- Changed `Datadog::AppSec::WAF::Context#run` interface to accommodate ephemeral data ([Breaking change](https://github.com/DataDog/libddwaf/blob/master/CHANGELOG.md#v1150-unstable))
+
+# 2023-09-11 v.1.14.0.0.0
+
+- Update to libddwaf 1.14.0
+- Add support for `Float` and `Nil` scalar values when converting from ruby to WAF Object and vice versa.
+
+# 2023-08-29 v.1.11.0.0.0
+
+- Update to libddwaf 1.11.0
+- Changed `Datadog::AppSec::WAF::Handle#ruleset_info` to `Datadog::AppSec::WAF::Handle#diagnostics`. (Breaking change)
+  The schema of the diagnostics variable can be found [here](https://github.com/DataDog/libddwaf/blob/master/schema/diagnostics.json)
+- Changed `Datadog::AppSec::WAF::Result#data` to `Datadog::AppSec::WAF::Result#events`. (Breaking change)
+  The schema of the events variable can be found [here](https://github.com/DataDog/libddwaf/blob/master/schema/events.json)
+
+# 2023-08-28 v.1.10.0.0.0
+
+- Update to libddwaf 1.10.0
+
+# 2023-06-13 v.1.9.0.0.1
+
+- Handle invalid encoding
+- Ensure strings passed to libddwaf are not clipped inside a code point
+- Ensure strings passed to libddwaf are UTF-8
+
+# 2023-05-17 v1.9.0.0.0
+
+- Update to libddwaf 1.9.0
+- Support [`custom_rules`](https://github.com/DataDog/libddwaf/pull/154)
+
+# 2023-03-03 v1.8.2.0.0
+
+- Update to libddwaf 1.8.2
+- Added Waf::Handle#merge method
+- Remove Waf::Handle#update_rule_data and Waf::Handle#toggle_rules methods
+- Remove WAF::LibDDWAF.ddwaf_required_rule_data_ids method
+
+# 2023-02-03 v1.7.0.0.0
+
+- Update to libddwaf 1.7.0
+
+# 2023-02-03 v1.6.2.0.0
+
+- Update to libddwaf 1.6.2
+- Add specs for the getter functions
+
+# 2023-02-01 v1.5.1.0.1
+
+- Fix incorrect size in input string limit
+- Fix object freeing on `update_rule_data` and `toggle_rules`
+
+# 2022-10-04 v1.5.1.0.0
+
+- Update to libddwaf 1.5.1
+- Add live rule data update API
+- Add live rule toggle API
+- Add libddwaf boolean type support
+- Add Ruby to libddwaf object conversion limits
+- Add Ruby to libddwaf object converter optional coercion of scalars to string
+- Add static type checking via RBS+Steep
+- Change version to return a string
+- Change free function to be passed as config instead of context init argument
+- Change result to include action list
+- Change return code from action to status
+- Change handle and context freeing model from GC-based to explicit
+- Fix double-free upon finalization of retained C objects
+- Fix context crash by retaining necessary C objects
+
+# 2022-05-20 v1.3.0.2.0
+
+- Fix multibyte string handling
+- Support JRuby
+
+# 2022-04-29 v1.3.0.1.0
+
+Promotion of v1.3.0.1.0.beta1 to stable
+
+# 2022-04-25 v1.3.0.1.0.beta1
+
+- Add obfuscator configuration
+- Add nested object limit configuration
+- Add report ruleset information
+
+# 2022-04-29 v1.3.0.0.0
+
+- Promote v1.3.0.0.0.beta1 to stable
+
+# 2022-04-20 v1.3.0.0.0.beta1
+
+- Update to libddwaf 1.3.0
+
+# 2022-03-18 v1.2.1.0.0.beta1
+
+- Update to libddwaf 1.2.1
+- Fix incorrect types for a few binding functions
+
+# 2022-03-04 v1.0.14.2.1.beta1
+
+- Fix incorrect return code
+- Fix passing nil in libddwaf object containers
+
+# 2022-02-07 v1.0.14.2.0.beta1
+
+- Change Datadog::Security to Datadog::AppSec
+
+# 2022-02-01 v1.0.14.1.0.beta2
+
+- Add support for Ruby 3.1
+
+# 2021-12-14 v1.0.14.1.0.beta1
+
+- Fix sequential runs on a single context by retaining C input data objects
+
+# 2021-11-24 v1.0.14.0.0.beta1
+
+- Update to libddwaf 1.0.14
+
+# 2021-11-24 v1.0.13.0.0.beta1
+
+- Add ruby platform fallback for unsupported platforms
+- Update to libddwaf 1.0.13
+
+# 2021-10-13 v1.0.12.0.0.beta1
+
+- Initial release

data/LICENSE

@@ -0,0 +1,6 @@
+## License
+
+This work is dual-licensed under Apache 2.0 or BSD3.
+You may select, at your option, one of the above-listed licenses.
+
+`SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause`

data/LICENSE-3rdparty.csv

@@ -0,0 +1,2 @@
+Component,Origin,License,Copyright
+core,https://github.com/ffi/ffi,BSD-3-Clause,"Copyright (c) 2008-2016, Ruby FFI project contributors"

data/LICENSE.Apache

@@ -0,0 +1,200 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2021 Datadog, Inc.
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/LICENSE.BSD3

@@ -0,0 +1,24 @@
+Copyright (c) 2021, Datadog <info@datadoghq.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Datadog nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/NOTICE

@@ -0,0 +1,4 @@
+Datadog libddwaf-rb
+Copyright 2021-Present Datadog, Inc.
+
+This product includes software developed at Datadog, Inc. (https://www.datadoghq.com/).

data/lib/datadog/appsec/waf/context.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    module WAF
+      # Ruby representation of the ddwaf_context in libddwaf
+      # See https://github.com/DataDog/libddwaf/blob/10e3a1dfc7bc9bb8ab11a09a9f8b6b339eaf3271/BINDING_IMPL_NOTES.md?plain=1#L125-L158
+      class Context
+        RESULT_CODE = {
+          ddwaf_ok: :ok,
+          ddwaf_match: :match,
+          ddwaf_err_internal: :err_internal,
+          ddwaf_err_invalid_object: :err_invalid_object,
+          ddwaf_err_invalid_argument: :err_invalid_argument
+        }.freeze
+
+        def initialize(context_ptr)
+          @context_ptr = context_ptr
+        end
+
+        # Destroys the WAF context and sets the pointer to nil.
+        #
+        # The instance becomes unusable after this method is called.
+        def finalize!
+          context_ptr_to_destroy = @context_ptr
+          @context_ptr = nil
+
+          retained.each do |retained_obj|
+            next unless retained_obj.is_a?(LibDDWAF::Object)
+
+            LibDDWAF.ddwaf_object_free(retained_obj)
+          end
+
+          retained.clear
+          LibDDWAF.ddwaf_context_destroy(context_ptr_to_destroy)
+        end
+
+        # Runs the WAF context with the given persistent and ephemeral data.
+        #
+        # @raise [ConversionError] if the conversion of persistent or ephemeral data fails
+        # @raise [LibDDWAFError] if libddwaf could not create the result object
+        #
+        # @return [Result] the result of the WAF run
+        def run(persistent_data, ephemeral_data, timeout = LibDDWAF::DDWAF_RUN_TIMEOUT)
+          ensure_pointer_presence!
+
+          persistent_data_obj = Converter.ruby_to_object(
+            persistent_data,
+            max_container_size: LibDDWAF::DDWAF_MAX_CONTAINER_SIZE,
+            max_container_depth: LibDDWAF::DDWAF_MAX_CONTAINER_DEPTH,
+            max_string_length: LibDDWAF::DDWAF_MAX_STRING_LENGTH,
+            coerce: false
+          )
+          if persistent_data_obj.null?
+            raise ConversionError, "Could not convert persistent data: #{persistent_data.inspect}"
+          end
+
+          # retain C objects in memory for subsequent calls to run
+          retain(persistent_data_obj)
+
+          ephemeral_data_obj = Converter.ruby_to_object(
+            ephemeral_data,
+            max_container_size: LibDDWAF::DDWAF_MAX_CONTAINER_SIZE,
+            max_container_depth: LibDDWAF::DDWAF_MAX_CONTAINER_DEPTH,
+            max_string_length: LibDDWAF::DDWAF_MAX_STRING_LENGTH,
+            coerce: false
+          )
+          if ephemeral_data_obj.null?
+            raise ConversionError, "Could not convert ephemeral data: #{ephemeral_data.inspect}"
+          end
+
+          result_obj = LibDDWAF::Result.new
+          raise LibDDWAFError, "Could not create result object" if result_obj.null?
+
+          code = LibDDWAF.ddwaf_run(@context_ptr, persistent_data_obj, ephemeral_data_obj, result_obj, timeout)
+
+          Result.new(
+            RESULT_CODE[code],
+            Converter.object_to_ruby(result_obj[:events]),
+            result_obj[:total_runtime],
+            result_obj[:timeout],
+            Converter.object_to_ruby(result_obj[:actions]),
+            Converter.object_to_ruby(result_obj[:derivatives])
+          )
+        ensure
+          LibDDWAF.ddwaf_result_free(result_obj) if result_obj
+          LibDDWAF.ddwaf_object_free(ephemeral_data_obj) if ephemeral_data_obj
+        end
+
+        private
+
+        def ensure_pointer_presence!
+          return if @context_ptr
+
+          raise InstanceFinalizedError, "Cannot use WAF context after it has been finalized"
+        end
+
+        def retained
+          @retained ||= []
+        end
+
+        def retain(object)
+          retained << object
+        end
+
+        def release(object)
+          retained.delete(object)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/waf/converter.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    module WAF
+      # Module responsible for Ruby-to-C and C-to-Ruby conversions
+      module Converter
+        module_function
+
+        # standard:disable Metrics/MethodLength,Metrics/CyclomaticComplexity
+        def ruby_to_object(val, max_container_size: nil, max_container_depth: nil, max_string_length: nil, coerce: true)
+          case val
+          when Array
+            obj = LibDDWAF::Object.new
+            res = LibDDWAF.ddwaf_object_array(obj)
+            raise ConversionError, "Could not convert into object: #{val}" if res.null?
+
+            max_index = max_container_size - 1 if max_container_size
+            unless max_container_depth == 0
+              val.each.with_index do |e, i|
+                member = Converter.ruby_to_object(
+                  e,
+                  max_container_size: max_container_size,
+                  max_container_depth: (max_container_depth - 1 if max_container_depth),
+                  max_string_length: max_string_length,
+                  coerce: coerce
+                )
+                e_res = LibDDWAF.ddwaf_object_array_add(obj, member)
+                raise ConversionError, "Could not add to array object: #{e.inspect}" unless e_res
+
+                break val if max_index && i >= max_index
+              end
+            end
+
+            obj
+          when Hash
+            obj = LibDDWAF::Object.new
+            res = LibDDWAF.ddwaf_object_map(obj)
+            raise ConversionError, "Could not convert into object: #{val}" if res.null?
+
+            max_index = max_container_size - 1 if max_container_size
+            unless max_container_depth == 0
+              val.each.with_index do |e, i|
+                # for Steep, which doesn't handle |(k, v), i|
+                k = e[0]
+                v = e[1]
+
+                k = k.to_s[0, max_string_length] if max_string_length
+                member = Converter.ruby_to_object(
+                  v,
+                  max_container_size: max_container_size,
+                  max_container_depth: (max_container_depth - 1 if max_container_depth),
+                  max_string_length: max_string_length,
+                  coerce: coerce
+                )
+                kv_res = LibDDWAF.ddwaf_object_map_addl(obj, k.to_s, k.to_s.bytesize, member)
+                raise ConversionError, "Could not add to map object: #{k.inspect} => #{v.inspect}" unless kv_res
+
+                break val if max_index && i >= max_index
+              end
+            end
+
+            obj
+          when String
+            obj = LibDDWAF::Object.new
+            encoded_val = val.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+            val = encoded_val[0, max_string_length] if max_string_length
+            str = val.to_s
+            res = LibDDWAF.ddwaf_object_stringl(obj, str, str.bytesize)
+            raise ConversionError, "Could not convert into object: #{val.inspect}" if res.null?
+
+            obj
+          when Symbol
+            obj = LibDDWAF::Object.new
+            val = val.to_s[0, max_string_length] if max_string_length
+            str = val.to_s
+            res = LibDDWAF.ddwaf_object_stringl(obj, str, str.bytesize)
+            raise ConversionError, "Could not convert into object: #{val.inspect}" if res.null?
+
+            obj
+          when Integer
+            obj = LibDDWAF::Object.new
+            res = if coerce
+              LibDDWAF.ddwaf_object_string(obj, val.to_s)
+            elsif val < 0
+              LibDDWAF.ddwaf_object_signed(obj, val)
+            else
+              LibDDWAF.ddwaf_object_unsigned(obj, val)
+            end
+            raise ConversionError, "Could not convert into object: #{val.inspect}" if res.null?
+
+            obj
+          when Float
+            obj = LibDDWAF::Object.new
+            res = if coerce
+              LibDDWAF.ddwaf_object_string(obj, val.to_s)
+            else
+              LibDDWAF.ddwaf_object_float(obj, val)
+            end
+            raise ConversionError, "Could not convert into object: #{val.inspect}" if res.null?
+
+            obj
+          when TrueClass, FalseClass
+            obj = LibDDWAF::Object.new
+            res = if coerce
+              LibDDWAF.ddwaf_object_string(obj, val.to_s)
+            else
+              LibDDWAF.ddwaf_object_bool(obj, val)
+            end
+            raise ConversionError, "Could not convert into object: #{val.inspect}" if res.null?
+
+            obj
+          when NilClass
+            obj = LibDDWAF::Object.new
+            res = if coerce
+              LibDDWAF.ddwaf_object_string(obj, "")
+            else
+              LibDDWAF.ddwaf_object_null(obj)
+            end
+            raise ConversionError, "Could not convert into object: #{val.inspect}" if res.null?
+
+            obj
+          else
+            Converter.ruby_to_object("")
+          end
+        end
+        # standard:enable Metrics/MethodLength,Metrics/CyclomaticComplexity
+
+        # standard:disable Metrics/MethodLength,Metrics/CyclomaticComplexity
+        def object_to_ruby(obj)
+          case obj[:type]
+          when :ddwaf_obj_invalid, :ddwaf_obj_null
+            nil
+          when :ddwaf_obj_bool
+            obj[:valueUnion][:boolean]
+          when :ddwaf_obj_string
+            # NOTE: FFI's `AbstractMemoryPointer#read_bytes` returns a binary string,
+            #       which is not automatically encoded as UTF-8 and will raise an error
+            #       if it contains non-ASCII characters and is used in a JSON#generate call.
+            bytes = obj[:valueUnion][:stringValue].read_bytes(obj[:nbEntries])
+            bytes.ascii_only? ? bytes : bytes.force_encoding(Encoding::UTF_8)
+          when :ddwaf_obj_signed
+            obj[:valueUnion][:intValue]
+          when :ddwaf_obj_unsigned
+            obj[:valueUnion][:uintValue]
+          when :ddwaf_obj_float
+            obj[:valueUnion][:f64]
+          when :ddwaf_obj_array
+            (0...obj[:nbEntries]).each.with_object([]) do |i, a|
+              ptr = obj[:valueUnion][:array] + i * LibDDWAF::Object.size
+              e = Converter.object_to_ruby(LibDDWAF::Object.new(ptr))
+              a << e # steep:ignore
+            end
+          when :ddwaf_obj_map
+            (0...obj[:nbEntries]).each.with_object({}) do |i, h|
+              ptr = obj[:valueUnion][:array] + i * Datadog::AppSec::WAF::LibDDWAF::Object.size
+              o = Datadog::AppSec::WAF::LibDDWAF::Object.new(ptr)
+              l = o[:parameterNameLength]
+              k = o[:parameterName].read_bytes(l)
+              v = Converter.object_to_ruby(LibDDWAF::Object.new(ptr))
+              h[k] = v # steep:ignore
+            end
+          end
+        end
+        # standard:enable Metrics/MethodLength,Metrics/CyclomaticComplexity
+      end
+    end
+  end
+end

data/lib/datadog/appsec/waf/errors.rb

@@ -0,0 +1,19 @@
+module Datadog
+  module AppSec
+    module WAF
+      Error = Class.new(StandardError)
+      InstanceFinalizedError = Class.new(Error)
+      ConversionError = Class.new(Error)
+
+      class LibDDWAFError < Error
+        attr_reader :diagnostics
+
+        def initialize(msg, diagnostics: nil)
+          @diagnostics = diagnostics
+
+          super(msg)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/waf/handle.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    module WAF
+      # Ruby representation of the ddwaf_handle in libddwaf
+      # See https://github.com/DataDog/libddwaf/blob/10e3a1dfc7bc9bb8ab11a09a9f8b6b339eaf3271/BINDING_IMPL_NOTES.md?plain=1#L4-L19
+      class Handle
+        def initialize(handle_ptr)
+          @handle_ptr = handle_ptr
+        end
+
+        # Destroys the WAF handle and sets the pointer to nil.
+        #
+        # The instance becomes unusable after this method is called.
+        def finalize!
+          handle_ptr_to_destroy = @handle_ptr
+          @handle_ptr = nil
+
+          LibDDWAF.ddwaf_destroy(handle_ptr_to_destroy)
+        end
+
+        # Builds a WAF context.
+        #
+        # @raise [LibDDWAFError] if libddwaf could not create the context.
+        # @return [Handle] the WAF handle
+        def build_context
+          ensure_pointer_presence!
+
+          context_obj = LibDDWAF.ddwaf_context_init(@handle_ptr)
+          raise LibDDWAFError, "Could not create context" if context_obj.null?
+
+          Context.new(context_obj)
+        end
+
+        # Returns the list of known addresses in the WAF handle.
+        #
+        # @return [Array<String>] the list of known addresses
+        def known_addresses
+          ensure_pointer_presence!
+
+          count = LibDDWAF::UInt32Ptr.new
+          list = LibDDWAF.ddwaf_known_addresses(@handle_ptr, count)
+
+          return [] if count == 0 # list is null
+
+          list.get_array_of_string(0, count[:value])
+        end
+
+        private
+
+        def ensure_pointer_presence!
+          return if @handle_ptr
+
+          raise InstanceFinalizedError, "Cannot use WAF handle after it has been finalized"
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/waf/handle_builder.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    module WAF
+      # This class represents the libddwaf WAF builder, which is used to generate WAF handles.
+      #
+      # It handles merging of potentially overlapping configurations.
+      class HandleBuilder
+        def initialize(limits: {}, obfuscator: {})
+          handle_config_obj = LibDDWAF::HandleBuilderConfig.new
+          if handle_config_obj.null?
+            raise LibDDWAFError, "Could not create config struct"
+          end
+
+          handle_config_obj[:limits][:max_container_size] = limits[:max_container_size] || LibDDWAF::DEFAULT_MAX_CONTAINER_SIZE
+          handle_config_obj[:limits][:max_container_depth] = limits[:max_container_depth] || LibDDWAF::DEFAULT_MAX_CONTAINER_DEPTH
+          handle_config_obj[:limits][:max_string_length] = limits[:max_string_length] || LibDDWAF::DEFAULT_MAX_STRING_LENGTH
+
+          handle_config_obj[:obfuscator][:key_regex] = FFI::MemoryPointer.from_string(obfuscator[:key_regex]) if obfuscator[:key_regex]
+          handle_config_obj[:obfuscator][:value_regex] = FFI::MemoryPointer.from_string(obfuscator[:value_regex]) if obfuscator[:value_regex]
+          handle_config_obj[:free_fn] = LibDDWAF::ObjectNoFree
+
+          @builder_ptr = LibDDWAF.ddwaf_builder_init(handle_config_obj)
+        end
+
+        # Destroys the WAF builder and sets the pointer to nil.
+        #
+        # The instance becomes unusable after this method is called.
+        def finalize!
+          builder_ptr_to_destroy = @builder_ptr
+          @builder_ptr = nil
+
+          LibDDWAF.ddwaf_builder_destroy(builder_ptr_to_destroy)
+        end
+
+        # Builds a WAF handle from the current state of the builder.
+        #
+        # @raise [LibDDWAFError] if no rules were added to the builder before building the handle
+        # @return [Handle] the WAF handle
+        def build_handle
+          ensure_pointer_presence!
+
+          handle_obj = LibDDWAF.ddwaf_builder_build_instance(@builder_ptr)
+          raise LibDDWAFError, "Could not create handle" if handle_obj.null?
+
+          Handle.new(handle_obj)
+        end
+
+        # :section: Configuration management methods
+        # methods for adding, updating, and removing configurations from the WAF handle builder.
+
+        # Adds or updates a configuration in the WAF handle builder for the given path.
+        #
+        # @return [Hash] diagnostics object
+        # NOTE: default config that was read from file at application startup
+        # has to be removed before adding configurations obtained through Remote Configuration.
+        def add_or_update_config(config, path:)
+          ensure_pointer_presence!
+
+          config_obj = Converter.ruby_to_object(config)
+          diagnostics_obj = LibDDWAF::Object.new
+
+          LibDDWAF.ddwaf_builder_add_or_update_config(@builder_ptr, path, path.length, config_obj, diagnostics_obj)
+
+          Converter.object_to_ruby(diagnostics_obj)
+        ensure
+          LibDDWAF.ddwaf_object_free(config_obj) if config_obj
+          LibDDWAF.ddwaf_object_free(diagnostics_obj) if diagnostics_obj
+        end
+
+        # Removes a configuration from the WAF handle builder for the given path.
+        #
+        # @return [Boolean] true if the configuration was removed, false otherwise
+        def remove_config_at_path(path)
+          ensure_pointer_presence!
+
+          LibDDWAF.ddwaf_builder_remove_config(@builder_ptr, path, path.length)
+        end
+
+        private
+
+        def ensure_pointer_presence!
+          return if @builder_ptr
+
+          raise InstanceFinalizedError, "Cannot use WAF handle builder after it has been finalized"
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/waf/lib_ddwaf.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "datadog/appsec/waf/version"
+
+module Datadog
+  module AppSec
+    module WAF
+      # FFI-binding for C-libddwaf
+      # See https://github.com/DataDog/libddwaf
+      module LibDDWAF
+        DEFAULT_MAX_CONTAINER_SIZE = 256
+        DEFAULT_MAX_CONTAINER_DEPTH = 20
+        DEFAULT_MAX_STRING_LENGTH = 16_384 # in bytes, UTF-8 worst case being 4x size in terms of code point
+
+        DDWAF_MAX_CONTAINER_SIZE = 256
+        DDWAF_MAX_CONTAINER_DEPTH = 20
+        DDWAF_MAX_STRING_LENGTH = 4096
+
+        DDWAF_RUN_TIMEOUT = 5000
+
+        extend ::FFI::Library
+
+        def self.local_os
+          if RUBY_ENGINE == "jruby"
+            os_name = java.lang.System.get_property("os.name")
+
+            os = case os_name
+            when /linux/i then "linux"
+            when /mac/i then "darwin"
+            else raise Error, "unsupported JRuby os.name: #{os_name.inspect}"
+            end
+
+            return os
+          end
+
+          Gem::Platform.local.os
+        end
+
+        def self.local_version
+          return nil unless local_os == "linux"
+
+          # Old rubygems don't handle non-gnu linux correctly
+          return ::Regexp.last_match(1) if RUBY_PLATFORM =~ /linux-(.+)$/
+
+          "gnu"
+        end
+
+        def self.local_cpu
+          if RUBY_ENGINE == "jruby"
+            os_arch = java.lang.System.get_property("os.arch")
+
+            cpu = case os_arch
+            when "amd64" then "x86_64"
+            when "aarch64" then (local_os == "darwin") ? "arm64" : "aarch64"
+            else raise Error, "unsupported JRuby os.arch: #{os_arch.inspect}"
+            end
+
+            return cpu
+          end
+
+          Gem::Platform.local.cpu
+        end
+
+        def self.source_dir
+          __dir__ || raise("__dir__ is nil: eval?")
+        end
+
+        def self.vendor_dir
+          File.join(source_dir, "../../../../vendor")
+        end
+
+        def self.libddwaf_vendor_dir
+          File.join(vendor_dir, "libddwaf")
+        end
+
+        def self.shared_lib_triplet(version: local_version)
+          version ? "#{local_os}-#{version}-#{local_cpu}" : "#{local_os}-#{local_cpu}"
+        end
+
+        def self.libddwaf_dir
+          default = File.join(libddwaf_vendor_dir,
+            "libddwaf-#{Datadog::AppSec::WAF::VERSION::BASE_STRING}-#{shared_lib_triplet}")
+          candidates = [
+            default
+          ]
+
+          if local_os == "linux"
+            candidates << File.join(libddwaf_vendor_dir,
+              "libddwaf-#{Datadog::AppSec::WAF::VERSION::BASE_STRING}-#{shared_lib_triplet(version: nil)}")
+          end
+
+          candidates.find { |d| Dir.exist?(d) } || default
+        end
+
+        def self.shared_lib_extname
+          if Gem::Platform.local.os == "darwin"
+            ".dylib"
+          elsif Gem::Platform.local.os == "java" && java.lang.System.get_property("os.name").match(/mac/i)
+            ".dylib"
+          else
+            ".so"
+          end
+        end
+
+        def self.shared_lib_path
+          File.join(libddwaf_dir, "lib", "libddwaf#{shared_lib_extname}")
+        end
+
+        ffi_lib [shared_lib_path]
+
+        # version
+
+        attach_function :ddwaf_get_version, [], :string
+
+        # ddwaf::object data structure
+
+        DDWAF_OBJ_TYPE = enum :ddwaf_obj_invalid, 0,
+          :ddwaf_obj_signed, 1 << 0,
+          :ddwaf_obj_unsigned, 1 << 1,
+          :ddwaf_obj_string, 1 << 2,
+          :ddwaf_obj_array, 1 << 3,
+          :ddwaf_obj_map, 1 << 4,
+          :ddwaf_obj_bool, 1 << 5,
+          :ddwaf_obj_float, 1 << 6,
+          :ddwaf_obj_null, 1 << 7
+
+        typedef DDWAF_OBJ_TYPE, :ddwaf_obj_type
+
+        typedef :pointer, :charptr
+        typedef :pointer, :charptrptr
+
+        # Ruby representation of C uint32_t
+        class UInt32Ptr < ::FFI::Struct
+          layout :value, :uint32
+        end
+
+        typedef UInt32Ptr.by_ref, :uint32ptr
+
+        # Ruby representation of C uint64_t
+        class UInt64Ptr < ::FFI::Struct
+          layout :value, :uint64
+        end
+
+        typedef UInt64Ptr.by_ref, :uint64ptr
+
+        # Ruby representation of C size_t
+        class SizeTPtr < ::FFI::Struct
+          layout :value, :size_t
+        end
+
+        typedef SizeTPtr.by_ref, :sizeptr
+
+        # Ruby representation of C union
+        class ObjectValueUnion < ::FFI::Union
+          layout :stringValue, :charptr,
+            :uintValue, :uint64,
+            :intValue, :int64,
+            :array, :pointer,
+            :boolean, :bool,
+            :f64, :double
+        end
+
+        # Ruby representation of ddwaf_object
+        # See https://github.com/DataDog/libddwaf/blob/10e3a1dfc7bc9bb8ab11a09a9f8b6b339eaf3271/include/ddwaf.h#L94C1-L115C3
+        class Object < ::FFI::Struct
+          layout :parameterName, :charptr,
+            :parameterNameLength, :uint64,
+            :valueUnion, ObjectValueUnion,
+            :nbEntries, :uint64,
+            :type, :ddwaf_obj_type
+        end
+
+        typedef Object.by_ref, :ddwaf_object
+
+        ## setters
+
+        attach_function :ddwaf_object_invalid, [:ddwaf_object], :ddwaf_object
+        attach_function :ddwaf_object_string, [:ddwaf_object, :string], :ddwaf_object
+        attach_function :ddwaf_object_stringl, [:ddwaf_object, :charptr, :size_t], :ddwaf_object
+        attach_function :ddwaf_object_stringl_nc, [:ddwaf_object, :charptr, :size_t], :ddwaf_object
+        attach_function :ddwaf_object_string_from_unsigned, [:ddwaf_object, :uint64], :ddwaf_object
+        attach_function :ddwaf_object_string_from_signed, [:ddwaf_object, :int64], :ddwaf_object
+        attach_function :ddwaf_object_unsigned, [:ddwaf_object, :uint64], :ddwaf_object
+        attach_function :ddwaf_object_signed, [:ddwaf_object, :int64], :ddwaf_object
+        attach_function :ddwaf_object_bool, [:ddwaf_object, :bool], :ddwaf_object
+        attach_function :ddwaf_object_null, [:ddwaf_object], :ddwaf_object
+        attach_function :ddwaf_object_float, [:ddwaf_object, :double], :ddwaf_object
+
+        attach_function :ddwaf_object_array, [:ddwaf_object], :ddwaf_object
+        attach_function :ddwaf_object_array_add, [:ddwaf_object, :ddwaf_object], :bool
+
+        attach_function :ddwaf_object_map, [:ddwaf_object], :ddwaf_object
+        attach_function :ddwaf_object_map_add, [:ddwaf_object, :string, :pointer], :bool
+        attach_function :ddwaf_object_map_addl, [:ddwaf_object, :charptr, :size_t, :pointer], :bool
+        attach_function :ddwaf_object_map_addl_nc, [:ddwaf_object, :charptr, :size_t, :pointer], :bool
+
+        ## getters
+
+        attach_function :ddwaf_object_type, [:ddwaf_object], DDWAF_OBJ_TYPE
+        attach_function :ddwaf_object_size, [:ddwaf_object], :uint64
+        attach_function :ddwaf_object_length, [:ddwaf_object], :size_t
+        attach_function :ddwaf_object_get_key, [:ddwaf_object, :sizeptr], :charptr
+        attach_function :ddwaf_object_get_string, [:ddwaf_object, :sizeptr], :charptr
+        attach_function :ddwaf_object_get_unsigned, [:ddwaf_object], :uint64
+        attach_function :ddwaf_object_get_signed, [:ddwaf_object], :int64
+        attach_function :ddwaf_object_get_index, [:ddwaf_object, :size_t], :ddwaf_object
+        attach_function :ddwaf_object_get_bool, [:ddwaf_object], :bool
+        attach_function :ddwaf_object_get_float, [:ddwaf_object], :double
+
+        ## freeers
+
+        ObjectFree = attach_function :ddwaf_object_free, [:ddwaf_object], :void
+        ObjectNoFree = ::FFI::Pointer::NULL
+
+        # handle builder
+
+        typedef :pointer, :ddwaf_builder
+        typedef :pointer, :ddwaf_handle
+        typedef :pointer, :ddwaf_diagnostics
+
+        callback :ddwaf_object_free_fn, [:ddwaf_object], :void
+
+        # Ruby representation of ddwaf_config
+        # https://github.com/DataDog/libddwaf/blob/10e3a1dfc7bc9bb8ab11a09a9f8b6b339eaf3271/include/ddwaf.h#L129-L152
+        class HandleBuilderConfig < ::FFI::Struct
+          # Ruby representation of ddwaf_config_limits
+          # https://github.com/DataDog/libddwaf/blob/10e3a1dfc7bc9bb8ab11a09a9f8b6b339eaf3271/include/ddwaf.h#L131-L138
+          class Limits < ::FFI::Struct
+            layout :max_container_size, :uint32,
+              :max_container_depth, :uint32,
+              :max_string_length, :uint32
+          end
+
+          # Ruby representation of ddwaf_config_obfuscator
+          # https://github.com/DataDog/libddwaf/blob/10e3a1dfc7bc9bb8ab11a09a9f8b6b339eaf3271/include/ddwaf.h#L141-L146
+          class Obfuscator < ::FFI::Struct
+            layout :key_regex, :pointer, # should be :charptr
+              :value_regex, :pointer  # should be :charptr
+          end
+
+          layout :limits, Limits,
+            :obfuscator, Obfuscator,
+            :free_fn, :pointer # :ddwaf_object_free_fn
+        end
+
+        typedef HandleBuilderConfig.by_ref, :ddwaf_config
+
+        attach_function :ddwaf_builder_init, [:ddwaf_config], :ddwaf_builder
+        attach_function :ddwaf_builder_destroy, [:ddwaf_builder], :void
+
+        attach_function :ddwaf_builder_add_or_update_config, [:ddwaf_builder, :string, :size_t, :ddwaf_object, :ddwaf_diagnostics], :bool
+        attach_function :ddwaf_builder_remove_config, [:ddwaf_builder, :string, :size_t], :bool
+
+        attach_function :ddwaf_builder_build_instance, [:ddwaf_builder], :ddwaf_handle
+
+        # handle
+
+        callback :ddwaf_object_free_fn, [:ddwaf_object], :void
+
+        attach_function :ddwaf_destroy, [:ddwaf_handle], :void
+
+        attach_function :ddwaf_known_addresses, [:ddwaf_handle, UInt32Ptr], :charptrptr
+
+        # updating
+
+        DDWAF_RET_CODE = enum :ddwaf_err_internal, -3,
+          :ddwaf_err_invalid_object, -2,
+          :ddwaf_err_invalid_argument, -1,
+          :ddwaf_ok, 0,
+          :ddwaf_match, 1
+        typedef DDWAF_RET_CODE, :ddwaf_ret_code
+
+        # running
+
+        typedef :pointer, :ddwaf_context
+
+        attach_function :ddwaf_context_init, [:ddwaf_handle], :ddwaf_context
+        attach_function :ddwaf_context_destroy, [:ddwaf_context], :void
+
+        # Ruby representation of ddwaf_result
+        # See https://github.com/DataDog/libddwaf/blob/10e3a1dfc7bc9bb8ab11a09a9f8b6b339eaf3271/include/ddwaf.h#L154-L173
+        class Result < ::FFI::Struct
+          layout :timeout, :bool,
+            :events, Object,
+            :actions, Object,
+            :derivatives, Object,
+            :total_runtime, :uint64
+        end
+
+        typedef Result.by_ref, :ddwaf_result
+        typedef :uint64, :timeout_us
+
+        attach_function :ddwaf_run, [:ddwaf_context, :ddwaf_object, :ddwaf_object, :ddwaf_result, :timeout_us], :ddwaf_ret_code, blocking: true
+        attach_function :ddwaf_result_free, [:ddwaf_result], :void
+
+        # logging
+
+        DDWAF_LOG_LEVEL = enum :ddwaf_log_trace,
+          :ddwaf_log_debug,
+          :ddwaf_log_info,
+          :ddwaf_log_warn,
+          :ddwaf_log_error,
+          :ddwaf_log_off
+        typedef DDWAF_LOG_LEVEL, :ddwaf_log_level
+
+        callback :ddwaf_log_cb, [:ddwaf_log_level, :string, :string, :uint, :charptr, :uint64], :void
+
+        attach_function :ddwaf_set_log_cb, [:ddwaf_log_cb, :ddwaf_log_level], :bool
+      end
+    end
+  end
+end

data/lib/datadog/appsec/waf/result.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    module WAF
+      # Ruby representation of the ddwaf_result of a libddwaf run.
+      # See https://github.com/DataDog/libddwaf/blob/10e3a1dfc7bc9bb8ab11a09a9f8b6b339eaf3271/include/ddwaf.h#L159-L173
+      class Result
+        attr_reader :status, :events, :total_runtime, :timeout, :actions, :derivatives
+
+        def initialize(status, events, total_runtime, timeout, actions, derivatives)
+          @status = status
+          @events = events
+          @total_runtime = total_runtime
+          @timeout = timeout
+          @actions = actions
+          @derivatives = derivatives
+        end
+
+        def to_h
+          {
+            status: @status,
+            events: @events,
+            total_runtime: @total_runtime,
+            timeout: @timeout,
+            actions: @actions,
+            derivatives: @derivatives
+          }
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/waf/version.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module AppSec
+    module WAF
+      module VERSION
+        BASE_STRING = "1.24.1"
+        # NOTE: Every change to the `BASE_STRING` should be accompanied
+        #       by a reset of the patch version in the `STRING` below.
+        STRING = "#{BASE_STRING}.0.0"
+        MINIMUM_RUBY_VERSION = "2.5"
+      end
+    end
+  end
+end

data/lib/datadog/appsec/waf.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "datadog/appsec/waf/lib_ddwaf"
+
+require "datadog/appsec/waf/handle_builder"
+require "datadog/appsec/waf/handle"
+require "datadog/appsec/waf/converter"
+require "datadog/appsec/waf/errors"
+require "datadog/appsec/waf/result"
+require "datadog/appsec/waf/context"
+require "datadog/appsec/waf/version"
+
+module Datadog
+  module AppSec
+    module WAF
+      module_function
+
+      def version
+        LibDDWAF.ddwaf_get_version
+      end
+
+      def log_callback(level, func, file, line, message, len)
+        return if WAF.logger.nil?
+
+        WAF.logger.debug do
+          {
+            level: level,
+            func: func,
+            file: file,
+            line: line,
+            message: message.read_bytes(len)
+          }.inspect
+        end
+      end
+
+      def logger
+        @logger
+      end
+
+      def logger=(logger)
+        unless @log_callback
+          log_callback = WAF.method(:log_callback)
+          LibDDWAF.ddwaf_set_log_cb(log_callback, :ddwaf_log_trace)
+
+          # retain logging proc if set properly
+          @log_callback = log_callback
+        end
+
+        @logger = logger
+      end
+    end
+  end
+end

data/lib/libddwaf.rb

@@ -0,0 +1 @@
+require "datadog/appsec/waf"

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: libddwaf
+version: !ruby/object:Gem::Version
+  version: 1.24.1.0.0
+platform: aarch64-linux-gnu
+authors:
+- Datadog, Inc.
+bindir: bin
+cert_chain: []
+date: 2025-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 'libddwaf packages a WAF implementation in C++, exposed to Ruby
+
+  '
+email:
+- dev@datadoghq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- LICENSE-3rdparty.csv
+- LICENSE.Apache
+- LICENSE.BSD3
+- NOTICE
+- lib/datadog/appsec/waf.rb
+- lib/datadog/appsec/waf/context.rb
+- lib/datadog/appsec/waf/converter.rb
+- lib/datadog/appsec/waf/errors.rb
+- lib/datadog/appsec/waf/handle.rb
+- lib/datadog/appsec/waf/handle_builder.rb
+- lib/datadog/appsec/waf/lib_ddwaf.rb
+- lib/datadog/appsec/waf/result.rb
+- lib/datadog/appsec/waf/version.rb
+- lib/libddwaf.rb
+- vendor/libddwaf/libddwaf-1.24.1-linux-aarch64/lib/libddwaf.so
+homepage: https://github.com/DataDog/libddwaf-rb
+licenses:
+- BSD-3-Clause
+metadata:
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Datadog WAF
+test_files: []