diff --git a/best-practices/MASTG-BEST-0029.md b/best-practices/MASTG-BEST-0029.md
new file mode 100644
index 00000000000..f597f38536d
--- /dev/null
+++ b/best-practices/MASTG-BEST-0029.md
@@ -0,0 +1,110 @@
+---
+title: Marking UI Views as Containing Sensitive Data
+alias: marking-ui-views-sensitive-data
+id: MASTG-BEST-0029
+platform: android
+knowledge: [MASTG-KNOW-0108]
+available_since: 35
+---
+
+## Overview
+
+Starting with Android 16 (API level 35), developers should mark sensitive UI views using the [`accessibilityDataSensitive`](https://developer.android.com/reference/android/view/View#attr_android:accessibilityDataSensitive) attribute to protect against malicious accessibility services. This protection prevents unauthorized apps with accessibility permissions from reading sensitive view content or performing interactions unless they are declared as legitimate accessibility tools via [`isAccessibilityTool`](https://developer.android.com/reference/android/accessibilityservice/AccessibilityServiceInfo#FLAG_ACCESSIBILITY_TOOL).
+
+## Recommendation
+
+Apply `accessibilityDataSensitive="true"` to views that handle or display sensitive information, such as:
+
+- Login screens (username and password fields)
+- Payment and transaction confirmation screens
+- Personal information forms (SSN, credit card numbers, etc.)
+- Two-factor authentication inputs
+- Biometric authentication prompts
+- Any view displaying confidential user data
+
+### XML Implementation
+
+```xml
+<EditText
+    android:id="@+id/passwordField"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:inputType="textPassword"
+    android:accessibilityDataSensitive="true" />
+
+<Button
+    android:id="@+id/confirmPayment"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="Confirm Payment"
+    android:accessibilityDataSensitive="true" />
+```
+
+### Programmatic Implementation
+
+```kotlin
+passwordField.setAccessibilityDataSensitive(View.ACCESSIBILITY_DATA_SENSITIVE_YES)
+confirmButton.setAccessibilityDataSensitive(View.ACCESSIBILITY_DATA_SENSITIVE_YES)
+```
+
+## Rationale
+
+Malicious apps can abuse Android's accessibility framework to:
+
+- Eavesdrop on sensitive user inputs (credentials, payment details)
+- Perform automated click injection on critical actions (approve transactions)
+- Extract confidential information displayed on screen
+- Conduct phishing attacks by monitoring user behavior
+
+By marking views as `accessibilityDataSensitive`, the system restricts non-tool accessibility services from accessing or interacting with these views, significantly reducing the attack surface for malware that relies on accessibility permissions.
+
+## Automatic Protection with filterTouchesWhenObscured
+
+Apps already using [`filterTouchesWhenObscured="true"`](https://developer.android.com/reference/android/view/View#setFilterTouchesWhenObscured(boolean)) for tapjacking protection automatically gain `accessibilityDataSensitive` benefits on Android 16+. This provides an instant additional layer of defense with no extra code:
+
+```xml
+<Button
+    android:id="@+id/transferFunds"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:filterTouchesWhenObscured="true" />
+    <!-- Automatically protected from malicious accessibility services on Android 16+ -->
+```
+
+If your app already implements `filterTouchesWhenObscured` on sensitive views, you receive this protection automatically. However, explicitly setting `accessibilityDataSensitive` is recommended for clarity and to ensure protection even if `filterTouchesWhenObscured` is later changed.
+
+## Considerations and Caveats
+
+### Legitimate Accessibility Tools
+
+This protection can impact legitimate accessibility services like screen readers. Users relying on accessibility tools may experience degraded functionality on marked views unless the accessibility service declares `isAccessibilityTool="true"`.
+
+- **Testing**: Test your app with popular accessibility tools (TalkBack, Voice Access) to ensure they can still function properly with marked views.
+- **User Communication**: If certain views must be marked sensitive for security, consider providing alternative accessible pathways or clear user guidance.
+
+### API Level Compatibility
+
+The `accessibilityDataSensitive` attribute is only available on Android 16 (API level 35) and higher. On older devices:
+
+- The attribute is ignored; the app functions normally without this protection
+- Consider using `filterTouchesWhenObscured` for broader compatibility against overlay attacks
+- Implement defense-in-depth by combining multiple security measures
+
+### Granularity
+
+Apply the attribute judiciously:
+
+- **Too Broad**: Marking entire screens reduces accessibility for users who need it
+- **Too Narrow**: Missing critical views leaves security gaps
+
+Focus on views that directly handle or display sensitive data, not general UI chrome.
+
+### View Hierarchy
+
+The `accessibilityDataSensitive` attribute can be inherited through the view hierarchy when using `View.ACCESSIBILITY_DATA_SENSITIVE_AUTO`. Plan your view structure to minimize repetition while ensuring comprehensive coverage.
+
+## References
+
+- [Android Developers Blog - Enhancing Android Security: Stop Malware with Accessibility Data Sensitivity](https://android-developers.googleblog.com/2025/12/enhancing-android-security-stop-malware.html)
+- [Android Security: Tapjacking Mitigations](https://developer.android.com/privacy-and-security/risks/tapjacking#mitigations)
+- [View.setAccessibilityDataSensitive](https://developer.android.com/reference/android/view/View#setAccessibilityDataSensitive(int))
diff --git a/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/MASTG-DEMO-0083.md b/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/MASTG-DEMO-0083.md
new file mode 100644
index 00000000000..1b3413de048
--- /dev/null
+++ b/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/MASTG-DEMO-0083.md
@@ -0,0 +1,72 @@
+---
+platform: android
+title: Detecting Accessibility Data Sensitivity in Layouts with semgrep
+id: MASTG-DEMO-0083
+code: [xml, kotlin]
+test: MASTG-TEST-0321
+---
+
+## Sample
+
+This sample demonstrates how to detect the use of `accessibilityDataSensitive` and `filterTouchesWhenObscured` attributes in Android layout files using Semgrep. The sample includes both properly protected views and views that lack protection.
+
+{{ activity_login.xml # MastgTest.kt }}
+
+### activity_login.xml
+
+The layout file contains several EditText fields for user credentials:
+
+1. `usernameField` - Has no protection (neither `accessibilityDataSensitive` nor `filterTouchesWhenObscured`)
+2. `passwordField` - Protected with `android:accessibilityDataSensitive="true"`
+3. `pinField` - Protected with `android:filterTouchesWhenObscured="true"` (which provides implicit accessibility protection on Android 16+)
+4. `creditCardField` - Protected with both `android:accessibilityDataSensitive="true"` and `android:filterTouchesWhenObscured="true"`
+
+### MastgTest.kt
+
+The Kotlin code demonstrates programmatic configuration of accessibility data sensitivity:
+
+1. Sets `accessibilityDataSensitive` on a button using the View API
+2. Checks the current state of `accessibilityDataSensitive` on views
+3. Sets `filterTouchesWhenObscured` which provides implicit protection
+
+## Steps
+
+Let's run our @MASTG-TOOL-0110 rule against the layout file and decompiled code.
+
+{{ ../../../../rules/mastg-android-accessibility-data-sensitive.yaml }}
+
+{{ run.sh }}
+
+## Observation
+
+The rule has identified:
+
+1. Views with explicit `accessibilityDataSensitive` attributes in XML
+2. Views with `filterTouchesWhenObscured` which provide implicit accessibility protection
+3. Programmatic calls to set or check accessibility data sensitivity
+4. Potentially sensitive input fields that lack any protection
+
+{{ output.txt }}
+
+## Evaluation
+
+Based on the Semgrep output:
+
+**Failures (views lacking protection):**
+
+- `usernameField` (line 12 in activity_login.xml): An EditText for username input lacks both `accessibilityDataSensitive` and `filterTouchesWhenObscured` protection. While usernames may be less sensitive than passwords, credential fields should generally be protected.
+
+**Passes (properly protected views):**
+
+- `passwordField` (line 23): Protected with `android:accessibilityDataSensitive="true"` - malicious accessibility services cannot read password input
+- `pinField` (line 34): Protected with `android:filterTouchesWhenObscured="true"` - gains implicit accessibility protection on Android 16+ while also preventing tapjacking
+- `creditCardField` (line 45): Protected with both attributes - defense in depth approach
+- `confirmButton` (line 18 in MastgTest.kt): Programmatically sets `ACCESSIBILITY_DATA_SENSITIVE_YES` for a payment confirmation button
+- Runtime checks (lines 22-23): The code properly checks current sensitivity settings
+
+**Recommendations:**
+
+1. Add `android:accessibilityDataSensitive="true"` or `android:filterTouchesWhenObscured="true"` to `usernameField`
+2. Consider using `filterTouchesWhenObscured` on all credential fields for broader protection across Android versions
+3. Review all payment and transaction confirmation buttons to ensure they are protected programmatically or in XML
+4. Test with legitimate accessibility tools (TalkBack, Voice Access) to ensure protected views remain accessible when needed
diff --git a/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/MastgTest.kt b/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/MastgTest.kt
new file mode 100644
index 00000000000..8c6c94562c3
--- /dev/null
+++ b/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/MastgTest.kt
@@ -0,0 +1,35 @@
+package org.owasp.mastestapp
+
+import android.os.Bundle
+import android.view.View
+import android.widget.Button
+import android.widget.EditText
+import androidx.appcompat.app.AppCompatActivity
+
+// SUMMARY: This sample demonstrates programmatic configuration of accessibility data sensitivity in Android.
+
+class MastgTest : AppCompatActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_login)
+
+        // PASS: [MASTG-TEST-0321] Programmatically set accessibility data sensitivity on a button
+        val confirmButton = findViewById<Button>(R.id.loginButton)
+        confirmButton.setAccessibilityDataSensitive(View.ACCESSIBILITY_DATA_SENSITIVE_YES)
+
+        // Check current sensitivity settings
+        val passwordField = findViewById<EditText>(R.id.passwordField)
+        val isDataSensitive = passwordField.accessibilityDataSensitive
+        val isFilteringTouches = passwordField.isFilterTouchesWhenObscured
+
+        // PASS: [MASTG-TEST-0321] Programmatically set filterTouchesWhenObscured for additional protection
+        val usernameField = findViewById<EditText>(R.id.usernameField)
+        usernameField.setFilterTouchesWhenObscured(true)
+
+        // Example: Conditionally disable protection (should be avoided for sensitive views)
+        // FAIL: [MASTG-TEST-0321] Never explicitly disable protection on sensitive views
+        // val creditCardField = findViewById<EditText>(R.id.creditCardField)
+        // creditCardField.setAccessibilityDataSensitive(View.ACCESSIBILITY_DATA_SENSITIVE_NO)
+    }
+}
diff --git a/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/activity_login.xml b/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/activity_login.xml
new file mode 100644
index 00000000000..4efb800cf36
--- /dev/null
+++ b/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/activity_login.xml
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- SUMMARY: This sample demonstrates various configurations of accessibility data sensitivity and filterTouchesWhenObscured in Android layouts. -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:padding="16dp">
+
+    <!-- FAIL: [MASTG-TEST-0321] Username field lacks protection from malicious accessibility services -->
+    <EditText
+        android:id="@+id/usernameField"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="Username"
+        android:inputType="text" />
+
+    <!-- PASS: [MASTG-TEST-0321] Password field is protected with explicit accessibilityDataSensitive -->
+    <EditText
+        android:id="@+id/passwordField"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="Password"
+        android:inputType="textPassword"
+        android:accessibilityDataSensitive="true" />
+
+    <!-- PASS: [MASTG-TEST-0321] PIN field is protected via filterTouchesWhenObscured (implicit accessibility protection on Android 16+) -->
+    <EditText
+        android:id="@+id/pinField"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="PIN"
+        android:inputType="numberPassword"
+        android:filterTouchesWhenObscured="true" />
+
+    <!-- PASS: [MASTG-TEST-0321] Credit card field is protected with both attributes for defense in depth -->
+    <EditText
+        android:id="@+id/creditCardField"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:hint="Credit Card Number"
+        android:inputType="number"
+        android:accessibilityDataSensitive="true"
+        android:filterTouchesWhenObscured="true" />
+
+    <Button
+        android:id="@+id/loginButton"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="Login" />
+
+</LinearLayout>
diff --git a/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/output.txt b/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/output.txt
new file mode 100644
index 00000000000..7153d039763
--- /dev/null
+++ b/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/output.txt
@@ -0,0 +1,60 @@
+=== Scanning XML Layout ===
+┌─────────────────┐
+│ 6 Code Findings │
+└─────────────────┘
+                      
+    activity_login.xml
+    ❯❱ rules.mastg-android-sensitive-view-without-protection
+          [MASVS-PLATFORM] Potentially sensitive view lacks accessibilityDataSensitive or
+          filterTouchesWhenObscured protection                                           
+                                                                                         
+           18┆ <EditText
+           19┆     android:id="@+id/passwordField"
+           20┆     android:layout_width="match_parent"
+           21┆     android:layout_height="wrap_content"
+           22┆     android:hint="Password"
+           23┆     android:inputType="textPassword"
+           24┆     android:accessibilityDataSensitive="true" />
+   
+     ❱ rules.mastg-android-accessibility-data-sensitive-xml
+          [MASVS-PLATFORM] View has accessibilityDataSensitive attribute set
+                                                                            
+           24┆ android:accessibilityDataSensitive="true" />
+   
+     ❱ rules.mastg-android-filter-touches-when-obscured-xml
+          [MASVS-PLATFORM] View has filterTouchesWhenObscured set (provides implicit
+          accessibilityDataSensitive protection on Android 16+)                     
+                                                                                    
+           33┆     android:filterTouchesWhenObscured="true" />
+   
+     ❱ rules.mastg-android-filter-touches-when-obscured-xml
+          [MASVS-PLATFORM] View has filterTouchesWhenObscured set (provides implicit
+          accessibilityDataSensitive protection on Android 16+)                     
+                                                                                    
+           43┆     android:filterTouchesWhenObscured="true" />
+   
+     ❱ rules.mastg-android-accessibility-data-sensitive-xml
+          [MASVS-PLATFORM] View has accessibilityDataSensitive attribute set
+                                                                            
+           42┆ android:accessibilityDataSensitive="true"
+
+=== Scanning Kotlin Code ===
+┌─────────────────┐
+│ 3 Code Findings │
+└─────────────────┘
+
+    MastgTest.kt
+     ❱ rules.mastg-android-set-accessibility-data-sensitive
+          [MASVS-PLATFORM] View's accessibility data sensitivity is being set programmatically
+
+           18┆ confirmButton.setAccessibilityDataSensitive(View.ACCESSIBILITY_DATA_SENSITIVE_YES)
+
+     ❱ rules.mastg-android-get-accessibility-data-sensitive
+          [MASVS-PLATFORM] Code is checking view's accessibility data sensitivity
+
+           22┆ val isDataSensitive = passwordField.accessibilityDataSensitive
+
+     ❱ rules.mastg-android-set-filter-touches-when-obscured
+          [MASVS-PLATFORM] View's filterTouchesWhenObscured is being set (provides implicit accessibility protection on Android 16+)
+
+           27┆ usernameField.setFilterTouchesWhenObscured(true)
diff --git a/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/run.sh b/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/run.sh
new file mode 100755
index 00000000000..ae4a939a38c
--- /dev/null
+++ b/demos/android/MASVS-PLATFORM/MASTG-DEMO-0083/run.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Run semgrep rules on the layout XML file
+echo "=== Scanning XML Layout ==="
+semgrep --config ../../../../rules/mastg-android-accessibility-data-sensitive.yaml activity_login.xml --text > output.txt 2>&1
+
+# Run semgrep rules on the Kotlin source code
+echo "" >> output.txt
+echo "=== Scanning Kotlin Code ===" >> output.txt
+semgrep --config ../../../../rules/mastg-android-accessibility-data-sensitive.yaml MastgTest.kt --text >> output.txt 2>&1
+
+cat output.txt
diff --git a/knowledge/android/MASVS-PLATFORM/MASTG-KNOW-0108.md b/knowledge/android/MASVS-PLATFORM/MASTG-KNOW-0108.md
new file mode 100644
index 00000000000..ca97c2fff7b
--- /dev/null
+++ b/knowledge/android/MASVS-PLATFORM/MASTG-KNOW-0108.md
@@ -0,0 +1,88 @@
+---
+masvs_category: MASVS-PLATFORM
+platform: android
+title: Accessibility Data Sensitivity
+available_since: 35
+---
+
+## Overview
+
+Starting with Android 16 (API level 35), the [`accessibilityDataSensitive`](https://developer.android.com/reference/android/view/View#attr_android:accessibilityDataSensitive) attribute provides a mechanism for developers to protect sensitive UI views from being accessed by accessibility services that are not legitimate accessibility tools. When this attribute is set to `true` on a view, the system restricts apps with accessibility permissions from reading or interacting with that view's content unless the accessibility service declares itself as a legitimate accessibility tool via [`isAccessibilityTool`](https://developer.android.com/reference/android/accessibilityservice/AccessibilityServiceInfo#FLAG_ACCESSIBILITY_TOOL) in its manifest.
+
+## Purpose and Behavior
+
+The `accessibilityDataSensitive` flag addresses a security concern where malicious apps can abuse Android's accessibility framework to eavesdrop on sensitive user interactions or inject clicks on behalf of the user. By marking views as sensitive, developers can:
+
+- Prevent unauthorized accessibility services from reading view content (text, descriptions, etc.)
+- Block non-legitimate accessibility services from performing clicks or other interactions on sensitive views
+- Protect against overlay attacks that exploit accessibility permissions
+
+## Configuration
+
+The attribute can be set in two ways:
+
+### XML Layout
+
+In layout files, developers can explicitly mark views as containing sensitive data:
+
+```xml
+<EditText
+    android:id="@+id/passwordField"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:accessibilityDataSensitive="true" />
+```
+
+### Programmatic API
+
+At runtime, developers can use the [`setAccessibilityDataSensitive()`](https://developer.android.com/reference/android/view/View#setAccessibilityDataSensitive(int)) method:
+
+```kotlin
+passwordField.setAccessibilityDataSensitive(View.ACCESSIBILITY_DATA_SENSITIVE_YES)
+```
+
+The method accepts three values:
+
+- `View.ACCESSIBILITY_DATA_SENSITIVE_AUTO` (default): Inherits from parent view or defaults based on other flags
+- `View.ACCESSIBILITY_DATA_SENSITIVE_YES`: Explicitly marks the view as sensitive
+- `View.ACCESSIBILITY_DATA_SENSITIVE_NO`: Explicitly marks the view as not sensitive
+
+## Automatic Enablement via filterTouchesWhenObscured
+
+An important feature is that views with [`filterTouchesWhenObscured`](https://developer.android.com/reference/android/view/View#setFilterTouchesWhenObscured(boolean)) set to `true` automatically inherit `accessibilityDataSensitive` protection. This means apps already using tapjacking protection gain accessibility security benefits without code changes:
+
+```xml
+<Button
+    android:id="@+id/confirmButton"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:filterTouchesWhenObscured="true" />
+    <!-- This button also gets accessibilityDataSensitive protection -->
+```
+
+## Legitimate Accessibility Tools
+
+For accessibility services to access views marked as sensitive, they must declare the `isAccessibilityTool` flag in their service configuration:
+
+```xml
+<accessibility-service
+    android:accessibilityFlags="flagReportViewIds"
+    android:isAccessibilityTool="true" />
+```
+
+Services declaring this flag should be legitimate accessibility tools like screen readers, magnification tools, or switch access utilities. Malicious apps attempting to abuse accessibility permissions typically would not declare this flag, as it subjects them to additional scrutiny during Play Store review and by users during installation.
+
+## Platform Enforcement
+
+When a non-tool accessibility service attempts to access a view marked as `accessibilityDataSensitive="true"`:
+
+- The view's content is redacted from accessibility events
+- Interaction attempts (clicks, long clicks, etc.) are blocked
+- The system logs a security event for audit purposes
+
+## References
+
+- [Android Developers Blog - Enhancing Android Security: Stop Malware with Accessibility Data Sensitivity](https://android-developers.googleblog.com/2025/12/enhancing-android-security-stop-malware.html)
+- [Android Security: Tapjacking Mitigations](https://developer.android.com/privacy-and-security/risks/tapjacking#mitigations)
+- [View.setAccessibilityDataSensitive](https://developer.android.com/reference/android/view/View#setAccessibilityDataSensitive(int))
+- [AccessibilityServiceInfo.isAccessibilityTool](https://developer.android.com/reference/android/accessibilityservice/AccessibilityServiceInfo#FLAG_ACCESSIBILITY_TOOL)
diff --git a/rules/mastg-android-accessibility-data-sensitive.yaml b/rules/mastg-android-accessibility-data-sensitive.yaml
new file mode 100644
index 00000000000..ce6961e6d2a
--- /dev/null
+++ b/rules/mastg-android-accessibility-data-sensitive.yaml
@@ -0,0 +1,88 @@
+rules:
+  - id: mastg-android-accessibility-data-sensitive-xml
+    severity: INFO
+    languages:
+      - xml
+    metadata:
+      summary: Views with accessibilityDataSensitive attribute in XML layouts
+    message: "[MASVS-PLATFORM] View has accessibilityDataSensitive attribute set"
+    patterns:
+      - pattern: <$VIEW ... android:accessibilityDataSensitive="$VALUE" ...>
+      - focus-metavariable: $VALUE
+
+  - id: mastg-android-filter-touches-when-obscured-xml
+    severity: INFO
+    languages:
+      - xml
+    metadata:
+      summary: Views with filterTouchesWhenObscured providing implicit accessibility protection
+    message: "[MASVS-PLATFORM] View has filterTouchesWhenObscured set (provides implicit accessibilityDataSensitive protection on Android 16+)"
+    patterns:
+      - pattern: <$VIEW ... android:filterTouchesWhenObscured="true" ...>
+
+  - id: mastg-android-set-accessibility-data-sensitive
+    severity: INFO
+    languages:
+      - java
+    metadata:
+      summary: Programmatic use of setAccessibilityDataSensitive method
+    message: "[MASVS-PLATFORM] View's accessibility data sensitivity is being set programmatically"
+    pattern-either:
+      - pattern: $VIEW.setAccessibilityDataSensitive($VALUE)
+
+  - id: mastg-android-get-accessibility-data-sensitive
+    severity: INFO
+    languages:
+      - java
+    metadata:
+      summary: Checking accessibility data sensitivity at runtime
+    message: "[MASVS-PLATFORM] Code is checking view's accessibility data sensitivity"
+    pattern-either:
+      - pattern: $VIEW.getAccessibilityDataSensitive()
+
+  - id: mastg-android-set-filter-touches-when-obscured
+    severity: INFO
+    languages:
+      - java
+    metadata:
+      summary: Programmatic use of setFilterTouchesWhenObscured method
+    message: "[MASVS-PLATFORM] View's filterTouchesWhenObscured is being set (provides implicit accessibility protection on Android 16+)"
+    pattern-either:
+      - pattern: $VIEW.setFilterTouchesWhenObscured($VALUE)
+
+  - id: mastg-android-is-filter-touches-when-obscured
+    severity: INFO
+    languages:
+      - java
+    metadata:
+      summary: Checking filterTouchesWhenObscured at runtime
+    message: "[MASVS-PLATFORM] Code is checking view's filterTouchesWhenObscured state"
+    pattern-either:
+      - pattern: $VIEW.isFilterTouchesWhenObscured()
+
+  - id: mastg-android-sensitive-view-without-protection
+    severity: WARNING
+    languages:
+      - xml
+    metadata:
+      summary: Potentially sensitive input fields without accessibility or overlay protection
+    message: "[MASVS-PLATFORM] Potentially sensitive view lacks accessibilityDataSensitive or filterTouchesWhenObscured protection"
+    patterns:
+      - pattern-either:
+          - pattern: |
+              <EditText
+                ...
+                android:inputType="textPassword"
+                ...>
+          - pattern: |
+              <EditText
+                ...
+                android:inputType="numberPassword"
+                ...>
+          - pattern: |
+              <EditText
+                ...
+                android:inputType="textVisiblePassword"
+                ...>
+      - pattern-not: <... android:accessibilityDataSensitive="true" ...>
+      - pattern-not: <... android:filterTouchesWhenObscured="true" ...>
diff --git a/tests-beta/android/MASVS-PLATFORM/MASTG-TEST-0321.md b/tests-beta/android/MASVS-PLATFORM/MASTG-TEST-0321.md
new file mode 100644
index 00000000000..50b3f1abd6f
--- /dev/null
+++ b/tests-beta/android/MASVS-PLATFORM/MASTG-TEST-0321.md
@@ -0,0 +1,67 @@
+---
+title: References to Accessibility Data Sensitivity APIs
+platform: android
+id: MASTG-TEST-0321
+type: [static]
+profiles: [L2]
+best-practices: [MASTG-BEST-0029]
+weakness: MASWE-0055
+knowledge: [MASTG-KNOW-0108]
+apis: [View, setAccessibilityDataSensitive, filterTouchesWhenObscured]
+available_since: 35
+---
+
+## Overview
+
+This test verifies whether an app references Android's accessibility data sensitivity APIs. Starting with Android 16 (API level 35), developers can use the [`accessibilityDataSensitive`](https://developer.android.com/reference/android/view/View#attr_android:accessibilityDataSensitive) attribute to protect sensitive views from malicious accessibility services. When set to `true` on a view, it restricts non-tool accessibility services from reading or interacting with sensitive content.
+
+Developers can apply this protection in two ways:
+
+1. **Explicit XML declaration**: Setting `android:accessibilityDataSensitive="true"` in layout files
+2. **Programmatic API**: Calling [`setAccessibilityDataSensitive(int)`](https://developer.android.com/reference/android/view/View#setAccessibilityDataSensitive(int)) with `View.ACCESSIBILITY_DATA_SENSITIVE_YES`
+3. **Implicit via filterTouchesWhenObscured**: Views with `android:filterTouchesWhenObscured="true"` automatically inherit accessibility data sensitivity protection on Android 16+
+
+Common failure modes include:
+
+- Not marking sensitive views (login fields, payment buttons, personal data forms) with `accessibilityDataSensitive`
+- Inconsistently applying protection across related sensitive screens
+- Explicitly disabling protection on sensitive views by setting `View.ACCESSIBILITY_DATA_SENSITIVE_NO`
+- Not leveraging automatic protection from existing `filterTouchesWhenObscured` flags
+
+## Steps
+
+1. Extract the app's layout XML files from the APK (@MASTG-TECH-0117).
+2. Run a static analysis tool (@MASTG-TECH-0014) to identify:
+    - Views with `android:accessibilityDataSensitive` set to `true` or `false`
+    - Views with `android:filterTouchesWhenObscured="true"` (which provide implicit protection)
+    - Calls to `setAccessibilityDataSensitive()` in decompiled code
+    - Calls to `setFilterTouchesWhenObscured()` in decompiled code
+3. Identify sensitive views based on their ID, type, or context (e.g., password fields, payment confirmation buttons).
+
+## Observation
+
+The output should include:
+
+1. A list of views with `android:accessibilityDataSensitive` explicitly set in XML layouts.
+2. A list of views with `android:filterTouchesWhenObscured="true"` (which gain implicit protection).
+3. A list of programmatic calls to `setAccessibilityDataSensitive()` in the codebase.
+4. A list of programmatic calls to `setFilterTouchesWhenObscured()` in the codebase.
+5. A mapping of identified sensitive views (by ID, type, or context) that should be protected.
+
+## Evaluation
+
+The test case fails if sensitive views that handle or display confidential information are not protected by `accessibilityDataSensitive` or `filterTouchesWhenObscured`. Specifically:
+
+- Password fields, PINs, credit card inputs, or other credential fields lack protection
+- Payment confirmation or transaction approval buttons are unprotected
+- Personal information forms (SSN, passport numbers, etc.) are not marked sensitive
+- The app explicitly disables protection on sensitive views using `View.ACCESSIBILITY_DATA_SENSITIVE_NO`
+
+The test passes if:
+
+- All sensitive views have `android:accessibilityDataSensitive="true"` in XML or call `setAccessibilityDataSensitive(View.ACCESSIBILITY_DATA_SENSITIVE_YES)` programmatically
+- Or, sensitive views use `android:filterTouchesWhenObscured="true"` to gain implicit protection on Android 16+
+- Protection is applied consistently across all screens handling sensitive data
+- No code paths explicitly disable the protection without justification
+
+**Note**: This test is applicable only for apps targeting Android 16 (API level 35) or higher. For apps targeting lower API levels, the attribute is ignored by the system, and alternative protections like `filterTouchesWhenObscured` should be evaluated separately.
diff --git a/tests-beta/android/MASVS-PLATFORM/MASTG-TEST-0322.md b/tests-beta/android/MASVS-PLATFORM/MASTG-TEST-0322.md
new file mode 100644
index 00000000000..815c52071d8
--- /dev/null
+++ b/tests-beta/android/MASVS-PLATFORM/MASTG-TEST-0322.md
@@ -0,0 +1,68 @@
+---
+title: Runtime Verification of Accessibility Data Sensitivity
+platform: android
+id: MASTG-TEST-0322
+type: [dynamic]
+profiles: [L2]
+best-practices: [MASTG-BEST-0029]
+weakness: MASWE-0055
+knowledge: [MASTG-KNOW-0108]
+apis: [View, getAccessibilityDataSensitive, setAccessibilityDataSensitive, isFilterTouchesWhenObscured]
+available_since: 35
+---
+
+## Overview
+
+This test is the dynamic counterpart to @MASTG-TEST-0321. It verifies that sensitive views in an Android app are properly configured with accessibility data sensitivity protection at runtime.
+
+At runtime, you can inspect view properties to determine:
+
+- Whether `accessibilityDataSensitive` is enabled using [`getAccessibilityDataSensitive()`](https://developer.android.com/reference/android/view/View#getAccessibilityDataSensitive())
+- Whether `filterTouchesWhenObscured` is enabled using [`isFilterTouchesWhenObscured()`](https://developer.android.com/reference/android/view/View#isFilterTouchesWhenObscured()), which provides implicit accessibility protection on Android 16+
+- Whether views handling sensitive data are protected appropriately
+
+This test focuses on observing the actual runtime configuration of views to ensure protection is active when the app is running.
+
+## Steps
+
+1. Install the app on a device running Android 16 (API level 35) or higher (@MASTG-TECH-0005).
+2. Use a dynamic analysis tool like @MASTG-TOOL-0031 (Frida) to:
+    - Enumerate all active View instances in the app's UI hierarchy
+    - For each view, call `getAccessibilityDataSensitive()` to check the current sensitivity setting
+    - For each view, call `isFilterTouchesWhenObscured()` to check if implicit protection is enabled
+    - Identify views by their resource ID, type, and context to determine if they handle sensitive data
+3. Navigate through sensitive screens in the app (login, payment, personal information forms) and collect runtime view configurations.
+
+## Observation
+
+The output should include:
+
+1. A list of all View instances found in the app's UI hierarchy with their:
+    - Resource ID (e.g., `@id/passwordField`)
+    - View type (e.g., `EditText`, `Button`)
+    - `accessibilityDataSensitive` setting (from `getAccessibilityDataSensitive()`)
+    - `filterTouchesWhenObscured` setting (from `isFilterTouchesWhenObscured()`)
+2. A classification of views as sensitive or non-sensitive based on their ID, type, and context.
+3. Any views where sensitivity settings change during app execution (e.g., via programmatic calls to `setAccessibilityDataSensitive()`).
+
+## Evaluation
+
+The test case fails if sensitive views are not properly protected at runtime:
+
+- Password fields, PIN inputs, or credential entry views have `ACCESSIBILITY_DATA_SENSITIVE_NO` or `ACCESSIBILITY_DATA_SENSITIVE_AUTO` without implicit protection from `filterTouchesWhenObscured`
+- Payment confirmation buttons, transaction approval actions lack accessibility sensitivity protection
+- Personal information forms (SSN, credit card details) are not marked as sensitive
+- Protection is inconsistently applied across related sensitive screens
+
+The test passes if:
+
+- All sensitive views return `View.ACCESSIBILITY_DATA_SENSITIVE_YES` from `getAccessibilityDataSensitive()`
+- Or, sensitive views return `true` from `isFilterTouchesWhenObscured()`, providing implicit accessibility protection on Android 16+
+- Protection is active and consistent across all screens handling sensitive data during runtime navigation
+- No runtime code paths dynamically disable the protection on sensitive views without justification
+
+**Note**: Views with `ACCESSIBILITY_DATA_SENSITIVE_AUTO` may inherit protection from parent views or from `filterTouchesWhenObscured`. Verify the effective protection by checking both the view and its parent hierarchy.
+
+**Additional Guidance**:
+
+If the app dynamically creates views or modifies their sensitivity settings at runtime, use method tracing or hooks to capture calls to `setAccessibilityDataSensitive()` and `setFilterTouchesWhenObscured()` to understand when and why protection is applied or removed. See @MASTG-TECH-0033 for method tracing techniques.