mobsec-modules-library 0.0.1__tar.gz

mobsec_modules_library-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Stormtrooperroman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mobsec_modules_library-0.0.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: mobsec_modules_library
+Version: 0.0.1
+Summary: Library for writing MobSec Modules using Python
+Author-email: Stormtrooperroman <stormtrooperroman@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Stormtrooperroman/mobsec_modules_library
+Project-URL: Issues, https://github.com/Stormtrooperroman/mobsec_modules_library/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: redis>=4.0.2
+Requires-Dist: fastapi>=0.68.0
+Requires-Dist: uvicorn>=0.15.0
+Dynamic: license-file
+
+# MobSec modules library
+
+Library to help write modules for [MobSec](https://github.com/Stormtrooperroman/MobSec)

mobsec_modules_library-0.0.1/README.md

@@ -0,0 +1,3 @@
+# MobSec modules library
+
+Library to help write modules for [MobSec](https://github.com/Stormtrooperroman/MobSec)

mobsec_modules_library-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "mobsec_modules_library"
+version = "0.0.1"
+authors = [
+  { name="Stormtrooperroman", email="stormtrooperroman@gmail.com" },
+]
+description = "Library for writing MobSec Modules using Python"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+dependencies = [
+    "redis>=4.0.2",
+    "fastapi>=0.68.0",
+    "uvicorn>=0.15.0"
+
+]
+
+[project.urls]
+Homepage = "https://github.com/Stormtrooperroman/mobsec_modules_library"
+Issues = "https://github.com/Stormtrooperroman/mobsec_modules_library/issues"
+
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+

mobsec_modules_library-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mobsec_modules_library-0.0.1/src/mobsec_modules_library/dynamic/__init__.py

@@ -0,0 +1,10 @@
+from .base_websocket_manager import BaseWebSocketManager
+from .base_module_manager import BaseModuleManager
+from .base_server import create_module_app, run_module_server
+
+__all__ = [
+    "BaseWebSocketManager",
+    "BaseModuleManager",
+    "create_module_app",
+    "run_module_server",
+]

mobsec_modules_library-0.0.1/src/mobsec_modules_library/dynamic/adb_utils.py

@@ -0,0 +1,114 @@
+"""ADB utilities"""
+
+import asyncio
+import logging
+import os
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def get_adb_env() -> Dict[str, str]:
+    return os.environ.copy()
+
+
+async def execute_adb_command(
+    device_id: str,
+    command: List[str],
+    env: Optional[Dict[str, str]] = None,
+) -> tuple[str, str, int]:
+    try:
+        adb_cmd = ["adb", "-H", "backend"]
+        if device_id:
+            adb_cmd.extend(["-s", device_id])
+        adb_cmd.extend(command)
+
+        process = await asyncio.create_subprocess_exec(
+            *adb_cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+        )
+        stdout, stderr = await process.communicate()
+
+        logger.info(stderr)
+        return stdout.decode(), stderr.decode(), process.returncode
+    except Exception as e:
+        logger.error("Error executing ADB command: %s", str(e))
+        return "", str(e), -1
+
+
+async def execute_adb_shell(
+    device_id: str,
+    shell_command: str,
+    env: Optional[Dict[str, str]] = None,
+) -> tuple[str, str, int]:
+    return await execute_adb_command(
+        device_id=device_id,
+        command=["shell", shell_command],
+        env=env,
+    )
+
+
+async def remove_all_port_forwarding(
+    device_id: Optional[str] = None,
+) -> tuple[str, str, int]:
+    return await execute_adb_command(
+        device_id=device_id,
+        command=["forward", "--remove-all"],
+        env=None,
+    )
+
+
+async def check_su_availability(device_id: str) -> bool:
+    """
+    Check su availability on device
+
+    Args:
+        device_id: Device ID
+
+    Returns:
+        True if su is available, False otherwise
+    """
+    try:
+        env = get_adb_env()
+
+        # First check if su exists
+        stdout, _, return_code = await execute_adb_shell(
+            device_id=device_id,
+            shell_command="which su",
+            env=env,
+        )
+
+        if return_code != 0:
+            logger.debug("su not found on device")
+            return False
+
+        # Check su functionality
+        stdout, _, return_code = await execute_adb_shell(
+            device_id=device_id,
+            shell_command='echo "echo SU_WORKS" | timeout 5 su 2>/dev/null || echo "SU_FAILED"',
+            env=env,
+        )
+
+        output = stdout.strip()
+
+        if "SU_WORKS" in output:
+            logger.debug("su is available and working")
+            return True
+
+        # Alternative check
+        stdout, _, return_code = await execute_adb_shell(
+            device_id=device_id,
+            shell_command='echo "exit" | su 2>/dev/null && echo "SU_SIMPLE_WORKS" || echo "SU_SIMPLE_FAILED"',
+            env=env,
+        )
+        simple_output = stdout.strip()
+
+        available = "SU_SIMPLE_WORKS" in simple_output
+        logger.debug("su availability: %s", available)
+        return available
+
+    except Exception as e:
+        logger.error("Error checking su availability: %s", str(e))
+        return False

mobsec_modules_library-0.0.1/src/mobsec_modules_library/dynamic/base_module_manager.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from fastapi import WebSocket
+
+
+class BaseModuleManager(ABC):
+
+    @abstractmethod
+    async def start(self) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def handle_message(
+        self, websocket: WebSocket, device_id: str, text: str
+    ) -> None:
+        raise NotImplementedError
+
+    async def stop(self) -> None:
+        return None

mobsec_modules_library-0.0.1/src/mobsec_modules_library/dynamic/base_server.py

@@ -0,0 +1,62 @@
+import logging
+import os
+from contextlib import asynccontextmanager
+from typing import Awaitable, Callable, Optional
+
+import uvicorn
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+from .base_module_manager import BaseModuleManager
+
+logger = logging.getLogger(__name__)
+
+ManagerFactory = Callable[[WebSocket, str], Awaitable[BaseModuleManager]]
+LifespanInit = Callable[[], Awaitable[None]]
+
+
+def create_module_app(
+    title: str,
+    manager_factory: ManagerFactory,
+    lifespan_init: Optional[LifespanInit] = None,
+) -> FastAPI:
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        if lifespan_init is not None:
+            await lifespan_init()
+        yield
+
+    app = FastAPI(title=title, lifespan=lifespan)
+
+    @app.websocket("/ws/{device_id}")
+    async def websocket_endpoint(websocket: WebSocket, device_id: str):
+        await websocket.accept()
+        logger.info("%s WebSocket connected for device %s", title, device_id)
+
+        manager = await manager_factory(websocket, device_id)
+        if not await manager.start():
+            await websocket.close(code=4000, reason=f"Failed to start {title} manager")
+            return
+
+        try:
+            while True:
+                message = await websocket.receive()
+                if message["type"] == "websocket.disconnect":
+                    break
+                if message["type"] == "websocket.receive" and "text" in message:
+                    await manager.handle_message(websocket, device_id, message["text"])
+        except WebSocketDisconnect:
+            logger.info("%s WebSocket disconnected for device %s", title, device_id)
+        except Exception as e:
+            logger.error(
+                "Error in %s session for device %s: %s", title, device_id, str(e)
+            )
+        finally:
+            await manager.stop()
+
+    return app
+
+
+def run_module_server(app: FastAPI, default_port: int) -> None:
+    port = int(os.getenv("PORT", str(default_port)))
+    uvicorn.run(app, host="0.0.0.0", port=port)

mobsec_modules_library-0.0.1/src/mobsec_modules_library/dynamic/base_websocket_manager.py

@@ -0,0 +1,29 @@
+import json
+import logging
+from typing import Any, Dict
+
+from fastapi import WebSocket
+
+logger = logging.getLogger(__name__)
+
+
+class BaseWebSocketManager:
+    """Base class for managers working with WebSocket."""
+
+    def __init__(self, websocket: WebSocket, manager_type: str):
+        self.websocket = websocket
+        self.manager_type = manager_type
+
+    async def send_response(self, data: Dict[str, Any]):
+        try:
+            if self.websocket.client_state.CONNECTED:
+                await self.websocket.send_text(json.dumps(data))
+            else:
+                logger.warning("WebSocket not connected, cannot send response")
+        except Exception as e:
+            logger.error("Error sending response: %s", str(e))
+
+    async def send_error(self, message: str, error_type: str = "error"):
+        await self.send_response(
+            {"type": self.manager_type, "action": error_type, "message": message}
+        )

mobsec_modules_library-0.0.1/src/mobsec_modules_library/static/static_module.py

@@ -0,0 +1,88 @@
+import redis
+import json
+import os
+import asyncio
+from typing import Dict, Any, List
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+
+logger = logging.getLogger(__name__)
+
+
+class StaticModule:
+    def __init__(self, module_name: str):
+        self.redis_client = redis.Redis.from_url(
+            os.getenv("REDIS_URL"), decode_responses=True
+        )
+        self.module_name = module_name
+
+    async def start(self):
+        logger.info(f"Starting {self.module_name} module...")
+        while True:
+            try:
+                queue_key = f"module:{self.module_name}:queue"
+                task_id = self.redis_client.lpop(queue_key)
+
+                if task_id:
+                    try:
+                        task_data_str = self.redis_client.get(f"task:{task_id}")
+                        if not task_data_str:
+                            logger.error(f"Task data not found for task_id: {task_id}")
+                            continue
+
+                        task_data = json.loads(task_data_str)
+                        logger.info(
+                            f"Processing task {task_id} for file: {task_data.get('file_hash')}"
+                        )
+
+                        result = await self.process(task_data)
+                        if not result:
+                            logger.error(
+                                f"No result returned from process for task {task_id}"
+                            )
+                            continue
+
+                        # Store result
+                        result_key = (
+                            f"result:{self.module_name}:{task_data['file_hash']}"
+                        )
+                        self.redis_client.set(result_key, json.dumps(result))
+                        logger.info(f"Successfully stored result for task {task_id}")
+
+                    except json.JSONDecodeError as e:
+                        logger.error(
+                            f"Failed to parse task data for task {task_id}: {str(e)}"
+                        )
+                    except redis.RedisError as e:
+                        logger.error(
+                            f"Redis error while processing task {task_id}: {str(e)}"
+                        )
+                    except Exception as e:
+                        import traceback
+
+                        logger.error(f"Error processing task {task_id}: {str(e)}")
+                        logger.error(f"Traceback: {traceback.format_exc()}")
+
+                await asyncio.sleep(1)
+
+            except Exception as e:
+                import traceback
+
+                logger.error(
+                    f"Critical error in {self.module_name} module main loop: {str(e)}"
+                )
+                logger.error(f"Traceback: {traceback.format_exc()}")
+                await asyncio.sleep(5)
+
+    async def process(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
+        pass
+
+    def summarize_results(self, scan_results: Dict) -> Dict[str, Any]:
+        pass
+
+    def process_findings(self, scan_results: Dict) -> List[Dict]:
+        pass

mobsec_modules_library-0.0.1/src/mobsec_modules_library.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: mobsec_modules_library
+Version: 0.0.1
+Summary: Library for writing MobSec Modules using Python
+Author-email: Stormtrooperroman <stormtrooperroman@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Stormtrooperroman/mobsec_modules_library
+Project-URL: Issues, https://github.com/Stormtrooperroman/mobsec_modules_library/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: redis>=4.0.2
+Requires-Dist: fastapi>=0.68.0
+Requires-Dist: uvicorn>=0.15.0
+Dynamic: license-file
+
+# MobSec modules library
+
+Library to help write modules for [MobSec](https://github.com/Stormtrooperroman/MobSec)

mobsec_modules_library-0.0.1/src/mobsec_modules_library.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/mobsec_modules_library/__init__.py
+src/mobsec_modules_library.egg-info/PKG-INFO
+src/mobsec_modules_library.egg-info/SOURCES.txt
+src/mobsec_modules_library.egg-info/dependency_links.txt
+src/mobsec_modules_library.egg-info/requires.txt
+src/mobsec_modules_library.egg-info/top_level.txt
+src/mobsec_modules_library/dynamic/__init__.py
+src/mobsec_modules_library/dynamic/adb_utils.py
+src/mobsec_modules_library/dynamic/base_module_manager.py
+src/mobsec_modules_library/dynamic/base_server.py
+src/mobsec_modules_library/dynamic/base_websocket_manager.py
+src/mobsec_modules_library/static/static_module.py

mobsec_modules_library-0.0.1/src/mobsec_modules_library.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mobsec_modules_library-0.0.1/src/mobsec_modules_library.egg-info/requires.txt

@@ -0,0 +1,3 @@
+redis>=4.0.2
+fastapi>=0.68.0
+uvicorn>=0.15.0

mobsec_modules_library-0.0.1/src/mobsec_modules_library.egg-info/top_level.txt

@@ -0,0 +1 @@
+mobsec_modules_library