Android superuser

[ixenion]

Question

Hi! Id like to form packets with scapy, but on android cant even import scapy.all - it says Permission denied.
How can we bypass that? My phone has root access, but cant understand: how to run flet app with root.

Code sample

import flet as ft
import os
import sys
import subprocess


SCAPY_AVAILABLE = False
IMPORT_ERROR = "Unknown"
scapy = None
try:
    # os.setuid(0)
    # os.setgid(0)

    try:
        from scapy.all import IP, Ether, scapy
        SCAPY_AVAILABLE = True
    except Exception as e:
        SCAPY_AVAILABLE = False
        IMPORT_ERROR = str(e)

except Exception as e:
    IMPORT_ERROR = str(e)


async def main(page: ft.Page):
    page.title = "Scapy + Flet Health Check"
    page.theme_mode = ft.ThemeMode.DARK
    page.vertical_alignment = ft.MainAxisAlignment.CENTER

    page.window.width = 450
    page.window.height = 900

    if SCAPY_AVAILABLE:
        try:
            test_pkt = Ether()/IP(dst="8.8.8.8")
            status_text = "SUCCESS"
            status_color = ft.Colors.GREEN
            details = (
                f"Scapy Version: {scapy.VERSION if scapy else 'N/A'}\n"
                f"UID: {os.getuid()}\n"
                f"Error: {IMPORT_ERROR}"
            )
        except Exception as e:
            status_text = "LOGIC ERROR"
            status_color = ft.Colors.ORANGE
            details = f"Import OK, but failed to build packet: {str(e)}"
    else:
        status_text = "IMPORT FAILED"
        status_color = ft.Colors.RED
        details = f"Scapy could not be loaded:\n{IMPORT_ERROR}"

    page.add(
            ft.Container(
                content=ft.Column(
                    controls=[
                        ft.Text("Scapy Integration Check", size=20, weight=ft.FontWeight.BOLD),
                        ft.Divider(),
                        ft.Row([
                            ft.Text("Status: "),
                            ft.Text(status_text, color=status_color, weight=ft.FontWeight.BOLD),
                        ]),
                        ft.Text(details, size=12, font_family="monospace"),
                    ],
                    tight=True,
                ),
                padding=ft.Padding.all(20),
                bgcolor=ft.Colors.SURFACE,
                # border_radius=15,
                width=350,
        )
    )
    await page.window.center()
    page.window.alignment = ft.Alignment.CENTER

if __name__ == "__main__":
    ft.run(main)

Error message

Permission denied

------------------------------------------------------

• I have searched for answers to my question both in the issues and in previous discussions.

[yudin-s]

Rooted Android does not automatically make a packaged Flet app run as a privileged process. The Python code still runs inside the app sandbox, so scapy can fail during import/probing, and raw packet work can still fail because the process does not have the needed raw-socket privileges.

I would first test the exact Scapy operation outside Flet:

adb shell su -c 'python -c "from scapy.all import IP, Ether; print(Ether()/IP(dst="8.8.8.8"))"'

If that fails, Flet cannot bypass it. If it works, keep Flet as the UI and call a small rooted helper with su -c for the privileged packet operation, then pass the result back to the app. Trying to make the whole Flet app root is the wrong boundary on Android.

If that clears it up, marking the answer would help others with the same Android/root question.

[ixenion]

Thanks! Iv already tested that, and managed to create and even emit custom packet via external wifi card which supports monitor mode.
The phone has proper drivers to handle external wifi dongle, so, technically it's possible via termux with root.

And frankly, that's how my app works right now - it uses termux as a root backend. But it's a crutch. :)

[yudin-s]

That result actually confirms the boundary: the working part is not "Python can do this on Android", it is "Termux is running the operation in a root-capable shell context". A packaged Flet APK will still be an Android app process with its own UID, SELinux/app sandbox rules, and no direct access to Termux's root session.

So I would treat Termux as the prototype backend, not as evidence that the Flet process can be made privileged. The cleaner production shape is usually a small rooted helper/service that owns the packet operation, with the Flet app calling it through a narrow command/API. That keeps the UI unprivileged and limits the root surface area to the exact operation that needs it.