npm - @runsec/mcp - Versions diffs - 1.0.1 - Mend

@runsec/mcp 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (40) hide show

package/dist/index.js +578 -0
package/package.json +43 -0
package/src/rules/data/rule-compliance-map.json +43563 -0
package/src/rules/data/semgrep-rules/README-taint-overlays.md +21 -0
package/src/rules/data/semgrep-rules/advanced-agent-cloud.yaml +802 -0
package/src/rules/data/semgrep-rules/app-logic.yaml +445 -0
package/src/rules/data/semgrep-rules/auth-keycloak.yaml +831 -0
package/src/rules/data/semgrep-rules/browser-agent.yaml +260 -0
package/src/rules/data/semgrep-rules/cloud-secrets.yaml +316 -0
package/src/rules/data/semgrep-rules/csharp-dotnet.yaml +4864 -0
package/src/rules/data/semgrep-rules/desktop-electron-pro.yaml +30 -0
package/src/rules/data/semgrep-rules/desktop-vsto-suite.yaml +2759 -0
package/src/rules/data/semgrep-rules/devops-security.yaml +393 -0
package/src/rules/data/semgrep-rules/domain-access-management.yaml +1023 -0
package/src/rules/data/semgrep-rules/domain-data-privacy.yaml +852 -0
package/src/rules/data/semgrep-rules/domain-input-validation.yaml +2894 -0
package/src/rules/data/semgrep-rules/domain-platform-hardening.yaml +1715 -0
package/src/rules/data/semgrep-rules/ds-ml-security.yaml +2431 -0
package/src/rules/data/semgrep-rules/fastapi-async.yaml +5953 -0
package/src/rules/data/semgrep-rules/frontend-react.yaml +4035 -0
package/src/rules/data/semgrep-rules/frontend-security.yaml +200 -0
package/src/rules/data/semgrep-rules/go-core.yaml +4959 -0
package/src/rules/data/semgrep-rules/hft-cpp-security.yaml +631 -0
package/src/rules/data/semgrep-rules/infra-k8s-helm.yaml +4968 -0
package/src/rules/data/semgrep-rules/integration-security.yaml +2362 -0
package/src/rules/data/semgrep-rules/java-enterprise.yaml +14756 -0
package/src/rules/data/semgrep-rules/java-spring.yaml +397 -0
package/src/rules/data/semgrep-rules/license-compliance.yaml +186 -0
package/src/rules/data/semgrep-rules/mobile-flutter.yaml +37 -0
package/src/rules/data/semgrep-rules/mobile-security.yaml +721 -0
package/src/rules/data/semgrep-rules/nodejs-nestjs.yaml +5164 -0
package/src/rules/data/semgrep-rules/nodejs-security.yaml +326 -0
package/src/rules/data/semgrep-rules/observability.yaml +381 -0
package/src/rules/data/semgrep-rules/php-security.yaml +3601 -0
package/src/rules/data/semgrep-rules/python-backend-pro.yaml +30 -0
package/src/rules/data/semgrep-rules/python-django.yaml +181 -0
package/src/rules/data/semgrep-rules/python-security.yaml +284 -0
package/src/rules/data/semgrep-rules/ru-regulatory.yaml +496 -0
package/src/rules/data/semgrep-rules/ruby-rails.yaml +3078 -0
package/src/rules/data/semgrep-rules/rust-security.yaml +2701 -0

package/src/rules/data/semgrep-rules/rust-security.yaml ADDED Viewed

@@ -0,0 +1,2701 @@
+rules:
+  - id: runsec.rust-security.rsx-001
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-001\\b'
+    message: |-
+      RunSec Detection [RSX-001]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-002
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-002\\b'
+    message: |-
+      RunSec Detection [RSX-002]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-003
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-003\\b'
+    message: |-
+      RunSec Detection [RSX-003]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-004
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-004\\b'
+    message: |-
+      RunSec Detection [RSX-004]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-005
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-005\\b'
+    message: |-
+      RunSec Detection [RSX-005]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-006
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-006\\b'
+    message: |-
+      RunSec Detection [RSX-006]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-007
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-007\\b'
+    message: |-
+      RunSec Detection [RSX-007]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-008
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-008\\b'
+    message: |-
+      RunSec Detection [RSX-008]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-009
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-009\\b'
+    message: |-
+      RunSec Detection [RSX-009]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-010
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-010\\b'
+    message: |-
+      RunSec Detection [RSX-010]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-011
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-011\\b'
+    message: |-
+      RunSec Detection [RSX-011]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-012
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-012\\b'
+    message: |-
+      RunSec Detection [RSX-012]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-013
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-013\\b'
+    message: |-
+      RunSec Detection [RSX-013]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-014
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-014\\b'
+    message: |-
+      RunSec Detection [RSX-014]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-015
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-015\\b'
+    message: |-
+      RunSec Detection [RSX-015]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-016
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-016\\b'
+    message: |-
+      RunSec Detection [RSX-016]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-017
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-017\\b'
+    message: |-
+      RunSec Detection [RSX-017]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-018
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-018\\b'
+    message: |-
+      RunSec Detection [RSX-018]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-019
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-019\\b'
+    message: |-
+      RunSec Detection [RSX-019]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-020
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-020\\b'
+    message: |-
+      RunSec Detection [RSX-020]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-021
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-021\\b'
+    message: |-
+      RunSec Detection [RSX-021]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-022
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-022\\b'
+    message: |-
+      RunSec Detection [RSX-022]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-023
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-023\\b'
+    message: |-
+      RunSec Detection [RSX-023]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-024
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-024\\b'
+    message: |-
+      RunSec Detection [RSX-024]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-025
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-025\\b'
+    message: |-
+      RunSec Detection [RSX-025]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-026
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-026\\b'
+    message: |-
+      RunSec Detection [RSX-026]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-027
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-027\\b'
+    message: |-
+      RunSec Detection [RSX-027]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-028
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-028\\b'
+    message: |-
+      RunSec Detection [RSX-028]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-029
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-029\\b'
+    message: |-
+      RunSec Detection [RSX-029]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-030
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-030\\b'
+    message: |-
+      RunSec Detection [RSX-030]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-031
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-031\\b'
+    message: |-
+      RunSec Detection [RSX-031]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-032
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-032\\b'
+    message: |-
+      RunSec Detection [RSX-032]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-033
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-033\\b'
+    message: |-
+      RunSec Detection [RSX-033]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-034
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-034\\b'
+    message: |-
+      RunSec Detection [RSX-034]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-035
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-035\\b'
+    message: |-
+      RunSec Detection [RSX-035]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-036
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-036\\b'
+    message: |-
+      RunSec Detection [RSX-036]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-037
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-037\\b'
+    message: |-
+      RunSec Detection [RSX-037]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-038
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-038\\b'
+    message: |-
+      RunSec Detection [RSX-038]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-039
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-039\\b'
+    message: |-
+      RunSec Detection [RSX-039]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-040
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-040\\b'
+    message: |-
+      RunSec Detection [RSX-040]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-041
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-041\\b'
+    message: |-
+      RunSec Detection [RSX-041]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-042
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-042\\b'
+    message: |-
+      RunSec Detection [RSX-042]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-043
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-043\\b'
+    message: |-
+      RunSec Detection [RSX-043]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-044
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-044\\b'
+    message: |-
+      RunSec Detection [RSX-044]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-045
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-045\\b'
+    message: |-
+      RunSec Detection [RSX-045]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-046
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-046\\b'
+    message: |-
+      RunSec Detection [RSX-046]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-047
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-047\\b'
+    message: |-
+      RunSec Detection [RSX-047]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-048
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-048\\b'
+    message: |-
+      RunSec Detection [RSX-048]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-049
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-049\\b'
+    message: |-
+      RunSec Detection [RSX-049]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-050
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-050\\b'
+    message: |-
+      RunSec Detection [RSX-050]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-051
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-051\\b'
+    message: |-
+      RunSec Detection [RSX-051]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-052
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-052\\b'
+    message: |-
+      RunSec Detection [RSX-052]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-053
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-053\\b'
+    message: |-
+      RunSec Detection [RSX-053]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-054
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-054\\b'
+    message: |-
+      RunSec Detection [RSX-054]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-055
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-055\\b'
+    message: |-
+      RunSec Detection [RSX-055]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-056
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-056\\b'
+    message: |-
+      RunSec Detection [RSX-056]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-057
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-057\\b'
+    message: |-
+      RunSec Detection [RSX-057]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-058
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-058\\b'
+    message: |-
+      RunSec Detection [RSX-058]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-059
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-059\\b'
+    message: |-
+      RunSec Detection [RSX-059]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-060
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-060\\b'
+    message: |-
+      RunSec Detection [RSX-060]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-061
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-061\\b'
+    message: |-
+      RunSec Detection [RSX-061]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-062
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-062\\b'
+    message: |-
+      RunSec Detection [RSX-062]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-063
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-063\\b'
+    message: |-
+      RunSec Detection [RSX-063]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-064
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-064\\b'
+    message: |-
+      RunSec Detection [RSX-064]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-065
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-065\\b'
+    message: |-
+      RunSec Detection [RSX-065]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-066
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-066\\b'
+    message: |-
+      RunSec Detection [RSX-066]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-067
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-067\\b'
+    message: |-
+      RunSec Detection [RSX-067]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-068
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-068\\b'
+    message: |-
+      RunSec Detection [RSX-068]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-069
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-069\\b'
+    message: |-
+      RunSec Detection [RSX-069]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-070
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-070\\b'
+    message: |-
+      RunSec Detection [RSX-070]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-071
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-071\\b'
+    message: |-
+      RunSec Detection [RSX-071]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-072
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-072\\b'
+    message: |-
+      RunSec Detection [RSX-072]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-073
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-073\\b'
+    message: |-
+      RunSec Detection [RSX-073]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-074
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-074\\b'
+    message: |-
+      RunSec Detection [RSX-074]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-075
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-075\\b'
+    message: |-
+      RunSec Detection [RSX-075]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-076
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-076\\b'
+    message: |-
+      RunSec Detection [RSX-076]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-077
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-077\\b'
+    message: |-
+      RunSec Detection [RSX-077]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-078
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-078\\b'
+    message: |-
+      RunSec Detection [RSX-078]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-079
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-079\\b'
+    message: |-
+      RunSec Detection [RSX-079]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-080
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-080\\b'
+    message: |-
+      RunSec Detection [RSX-080]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-081
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-081\\b'
+    message: |-
+      RunSec Detection [RSX-081]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-082
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-082\\b'
+    message: |-
+      RunSec Detection [RSX-082]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-083
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-083\\b'
+    message: |-
+      RunSec Detection [RSX-083]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-084
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-084\\b'
+    message: |-
+      RunSec Detection [RSX-084]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-085
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-085\\b'
+    message: |-
+      RunSec Detection [RSX-085]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-086
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-086\\b'
+    message: |-
+      RunSec Detection [RSX-086]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-087
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-087\\b'
+    message: |-
+      RunSec Detection [RSX-087]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-088
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-088\\b'
+    message: |-
+      RunSec Detection [RSX-088]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-089
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-089\\b'
+    message: |-
+      RunSec Detection [RSX-089]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-090
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-090\\b'
+    message: |-
+      RunSec Detection [RSX-090]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-091
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-091\\b'
+    message: |-
+      RunSec Detection [RSX-091]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-092
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-092\\b'
+    message: |-
+      RunSec Detection [RSX-092]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-093
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-093\\b'
+    message: |-
+      RunSec Detection [RSX-093]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-094
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-094\\b'
+    message: |-
+      RunSec Detection [RSX-094]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-095
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-095\\b'
+    message: |-
+      RunSec Detection [RSX-095]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-096
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-096\\b'
+    message: |-
+      RunSec Detection [RSX-096]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-097
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-097\\b'
+    message: |-
+      RunSec Detection [RSX-097]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-098
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-098\\b'
+    message: |-
+      RunSec Detection [RSX-098]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-099
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-099\\b'
+    message: |-
+      RunSec Detection [RSX-099]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-100
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-100\\b'
+    message: |-
+      RunSec Detection [RSX-100]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-101
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-101\\b'
+    message: |-
+      RunSec Detection [RSX-101]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-102
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-102\\b'
+    message: |-
+      RunSec Detection [RSX-102]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-103
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-103\\b'
+    message: |-
+      RunSec Detection [RSX-103]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-104
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-104\\b'
+    message: |-
+      RunSec Detection [RSX-104]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-105
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-105\\b'
+    message: |-
+      RunSec Detection [RSX-105]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-106
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-106\\b'
+    message: |-
+      RunSec Detection [RSX-106]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-107
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-107\\b'
+    message: |-
+      RunSec Detection [RSX-107]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-108
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-108\\b'
+    message: |-
+      RunSec Detection [RSX-108]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-109
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-109\\b'
+    message: |-
+      RunSec Detection [RSX-109]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-110
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-110\\b'
+    message: |-
+      RunSec Detection [RSX-110]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-111
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-111\\b'
+    message: |-
+      RunSec Detection [RSX-111]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-112
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-112\\b'
+    message: |-
+      RunSec Detection [RSX-112]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-113
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-113\\b'
+    message: |-
+      RunSec Detection [RSX-113]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-114
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-114\\b'
+    message: |-
+      RunSec Detection [RSX-114]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-115
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-115\\b'
+    message: |-
+      RunSec Detection [RSX-115]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-116
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-116\\b'
+    message: |-
+      RunSec Detection [RSX-116]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-117
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-117\\b'
+    message: |-
+      RunSec Detection [RSX-117]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-118
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-118\\b'
+    message: |-
+      RunSec Detection [RSX-118]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-119
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-119\\b'
+    message: |-
+      RunSec Detection [RSX-119]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-120
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-120\\b'
+    message: |-
+      RunSec Detection [RSX-120]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-121
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-121\\b'
+    message: |-
+      RunSec Detection [RSX-121]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-122
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-122\\b'
+    message: |-
+      RunSec Detection [RSX-122]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-123
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-123\\b'
+    message: |-
+      RunSec Detection [RSX-123]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-124
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-124\\b'
+    message: |-
+      RunSec Detection [RSX-124]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-125
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-125\\b'
+    message: |-
+      RunSec Detection [RSX-125]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-126
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-126\\b'
+    message: |-
+      RunSec Detection [RSX-126]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-127
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-127\\b'
+    message: |-
+      RunSec Detection [RSX-127]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-128
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-128\\b'
+    message: |-
+      RunSec Detection [RSX-128]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-129
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-129\\b'
+    message: |-
+      RunSec Detection [RSX-129]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-130
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-130\\b'
+    message: |-
+      RunSec Detection [RSX-130]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-131
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-131\\b'
+    message: |-
+      RunSec Detection [RSX-131]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-132
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-132\\b'
+    message: |-
+      RunSec Detection [RSX-132]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-133
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-133\\b'
+    message: |-
+      RunSec Detection [RSX-133]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-134
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-134\\b'
+    message: |-
+      RunSec Detection [RSX-134]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-135
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-135\\b'
+    message: |-
+      RunSec Detection [RSX-135]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-136
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-136\\b'
+    message: |-
+      RunSec Detection [RSX-136]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-137
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-137\\b'
+    message: |-
+      RunSec Detection [RSX-137]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-138
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-138\\b'
+    message: |-
+      RunSec Detection [RSX-138]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-139
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-139\\b'
+    message: |-
+      RunSec Detection [RSX-139]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-140
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-140\\b'
+    message: |-
+      RunSec Detection [RSX-140]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-141
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-141\\b'
+    message: |-
+      RunSec Detection [RSX-141]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-142
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-142\\b'
+    message: |-
+      RunSec Detection [RSX-142]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-143
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-143\\b'
+    message: |-
+      RunSec Detection [RSX-143]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-144
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-144\\b'
+    message: |-
+      RunSec Detection [RSX-144]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-145
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-145\\b'
+    message: |-
+      RunSec Detection [RSX-145]: CWE-362
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-146
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked unsafe pointer access can cause undefined behavior and memory corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          unsafe { *ptr = value; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-146\\b'
+    message: |-
+      RunSec Detection [RSX-146]: CWE-119
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-147
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Leaked async resources accumulate and degrade service availability.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let conn = pool.get().await?; if bad { return Ok(()); }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-147\\b'
+    message: |-
+      RunSec Detection [RSX-147]: CWE-772
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-148
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unchecked arithmetic overflows can break business logic and risk funds integrity.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let total = price * quantity;
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-148\\b'
+    message: |-
+      RunSec Detection [RSX-148]: CWE-190
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-149
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Type punning via transmute may break layout assumptions and trigger UB.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          let out: Target = unsafe { std::mem::transmute(input) };
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-149\\b'
+    message: |-
+      RunSec Detection [RSX-149]: CWE-704
+    languages:
+      - generic
+    severity: WARNING
+  - id: runsec.rust-security.rsx-150
+    metadata:
+      runsec_version: v1.0
+      confidence: |-
+        0.9
+      exploit_scenario: |-
+        Unsynchronized mutable state causes races and nondeterministic state corruption.
+      fix_template: |-
+        Autofix: replace unsafe math/memory/state operations with checked and synchronized primitives.
+    pattern-either:
+      - pattern: |-
+          static mut COUNTER: u64 = 0; unsafe { COUNTER += 1; }
+      - pattern-regex: 'Vulnerable:\\s*RSX\\-150\\b'
+    message: |-
+      RunSec Detection [RSX-150]: CWE-362
+    languages:
+      - generic
+    severity: WARNING