DedSec Project: a complete portable Linux & cybersecurity lab on Android

From a simple mobile phone to a portable technical laboratory

Today's Android phones have multi-core processors, enough memory, and storage to handle tasks that only a few years ago required a PC. However, Android is still designed primarily around graphical applications. The user rarely has direct access to command-line tools, programming languages, Git, SSH, or packages reminiscent of a classic GNU/Linux distribution.

Termux changes this picture. It offers a terminal and a package environment that runs directly on Android, usually without root. Through it, Python, Git, OpenSSH, text editors, network tools, compilers, and many other applications can be installed. For a beginner, however, this freedom comes with a practical obstacle: they need to know which packages they need, how to manage permissions and paths, how to organize their scripts, and what to do when an installation fails.

This is where the DedSec Project comes in. Rather than being a single script, it functions as an organized ecosystem. The installation creates a single starting point from which the user can open tools, change language and appearance, update the project, create backups, and find instructions for common Termux problems.

What exactly is the DedSec Project?

The DedSec Project is a comprehensive educational toolkit for Android and Termux. It includes Python and Bash scripts, local browser interfaces, file utilities, diagnostics, network utilities, OSINT and awareness labs, and practice environments. Everything is organized into categories and offered through central menus, so the user doesn't have to remember dozens of different commands and paths.

Its orientation is primarily educational and defensive. This means that network tools, web reconnaissance, or social-engineering awareness are only meaningful on systems owned by the user or in environments where there is clear authorization. The project's official security policy rejects use to access, disrupt, or control foreign systems without permission.

At the same time, the project is not limited to cybersecurity. A large part of it concerns software development, file management, local servers, creating web applications, installing Linux desktops, and automating daily tasks. Thus, it can be used by both someone starting with the command line and a more experienced user who wants an organized mobile-first environment.

The central experience: menus, settings and bilingual operation

The core experience revolves around Settings.py and the project menus. From there, the user can view device and installation information, update the repository, upgrade packages and Python modules, connect or disconnect a GitHub account, change the Termux prompt, select a language, and manage the startup method.

There are different menu styles, such as list, grid, numbered selection, and DedSec OS. For a new user, the simple list or numbered menu is usually more practical, because it clearly displays the available categories. The language can be saved in Greek or English, so that the same environment can be used by people who are not comfortable with exclusively English technical terminology.

The backup feature is also important. The project can create a saved package in Downloads, so that a working installation can be restored more easily after a device change, storage issue, or failed upgrade. The official documentation recommends creating the first backup immediately after initial setup and updating it periodically.

DedSec OS: local desktop environment within the browser

DedSec OS takes a different approach to the classic terminal menu. It opens a local browser-based workspace and brings together a file browser, secure text editor, terminal viewer, session manager, DedSec application launcher, and basic Linux package management actions.

It also includes notifications, full-screen mode, split view, sidebar and wallpaper customization, display name and terminal color settings, language and prompt controls, as well as optional password login, authenticator-style 2FA, and recovery via security questions. The goal is not to replace a full desktop operating system, but to make common project actions more visual and accessible from mobile.

The main categories of tools

The collection is constantly evolving, so the exact number and names of scripts may change. However, the main functional categories remain constant:

1. Developer Base and file management

Developer Base gathers tools that help in daily technical work. It includes functions for converting images, audio, video, documents and compressed files, recognizing the actual file type, reading metadata and calculating hashes. Such functions are useful when a file has the wrong extension, when integrity checking is needed or when bulk files need to be organized from the mobile.

There are also tools for web development, mobile development, folder management, duplicate detection, reminders, notes, and local file servers. The idea is to allow the user to perform common development and organization tasks without constantly transferring their data to a computer.

Mobile Desktop can install and manage a Linux desktop via proot-distro, with VNC or X11 options and without root requirement. This allows the use of graphical Linux applications, provided the device has enough memory and storage space.

2. Termux Diagnosis and Repair

One of the most practical sections is the DedSec Termux Repair Wizard. It looks at common problem categories: repository and mirror errors, apt or dpkg failures, missing storage permissions, TLS certificates, corrupted caches, Python or pip issues, and incorrect shell and PATH settings.

Its usefulness doesn't just lie in automatic correction. It tries to present the problem in a structured way so that the user can understand if a package is missing, if a command is being run from the wrong folder, or if a dependency is incompatible with Android.

Script Keeper logic works in a complementary manner: it can scan scripts and folders, identify possible runtimes, commands, and Python modules that are required, and generate a report before execution. This reduces “command not found” or “module not found” failures and helps maintain larger script collections.

3. Network tools, web checks and OSINT awareness

The network and OSINT category includes tools for local network audits, link analysis, basic web reconnaissance, and collection of publicly available information. A user can, for example, examine redirects, certificates, and key attributes of a URL before opening it, or record devices located on their own local network.

Bug Hunter is an example of a tool intended for authorized web security reconnaissance. It can examine security headers, cookie flags, DNS settings such as SPF, DMARC, and CAA, TLS certificates, CORS, HTTP methods, and potentially exposed files. It can also crawl and analyze JavaScript for endpoints or potential secrets, generating reports in different formats.

These capabilities are dual-purpose. On our own site or in an official penetration-testing scope, they can reveal configuration errors and improve security. On a foreign system without permission, the same behavior is unauthorized. For this reason, the project emphasizes consent, scope limitation, and responsible use.

4. Awareness labs and educational simulations

The DedSec Project also includes mock pages, or social engineering simulations. Their goal is to show how deceptive pages, fake giveaways, suspicious login prompts, and permission requests that exploit user trust work.

These labs should only be used with test data, dummy accounts, and explicit consent. They are not tools for collecting real passwords, payment details, location, or other personal data. Their educational value lies in helping the user learn to recognize fraud patterns, not in applying them to others.

For cybersecurity educators, this approach can be useful in a closed lab: students see how a persuasive page can direct their behavior, discuss the warning signs, and then analyze the code and logs without exposing a real person.

5. DedSec Market and organized repository management

DedSec Market works as a curses-based directory of GitHub repositories customized for Termux. Instead of just displaying the raw repository name, it displays the project name, reads the README, displays releases and issues, and allows install, update, delete, and launch actions.

It maintains watchlist, cache, and local state for faster reuse. This feature is especially useful on a mobile device, where navigating between browser, GitHub, and terminal can become tedious. The user still has to check the reliability of each repository and the code they install, but the organization becomes more consistent.

ButSystem.py: local-first private collaboration space

One of the most ambitious extensions of the ecosystem is ButSystem.py. It is a self-hosted, local-first workspace running through Termux and opening in the browser. It combines instant chat, groups, saved messages, stories, file sharing, profiles, private vault, encrypted recordings, news, and weather into a single interface.

The local-first philosophy means that the core environment and data are hosted on the user's device or network, rather than necessarily relying on a central commercial server. ButSystem can create local links and, when the corresponding services are available, Cloudflared or Tor links. It can also create QR codes and controlled file sharing links with optional code, expiration and revocation.

At the access level, it supports user approval, device access requests, remembered-device login, optional two-factor authentication via security questions, PIN locks for conversations, reports, and admin pages. The private vault and Profiler offer search, import, export, and merging of records, while optional live location is based on explicit user selection.

While ButSystem is interesting as a self-hosting experiment and as an example of a complex local web application, it should not be automatically treated as a replacement for independently audited secure communication platforms. Truly sensitive use requires external code audits, proper key management, secure network configuration, and a clear threat model. Its value lies primarily in showing how complex a phone-hosted workspace can become.

Installation on Android

The official documentation recommends Termux from F-Droid, as versions from other stores may be older or have limitations. For full functionality, Termux:API and Termux:Styling are also recommended.

 

Requirement	Minimum / recommended
Device	Android phone or tablet with Termux
RAM	At least 2 GB
Free space	At least 8 GB
LOG IN	Required for first installation and updates

 

Step 1: Updating packages and accessing the repository

pkg update -y && pkg upgrade -y && pkg install git nano -y && termux-setup-storage

The command updates the package list, upgrades what is already installed, installs Git and Nano, and requests access to Android's shared storage. When the relevant permissions window appears, the user must allow access if they want the project to store files in Downloads.

Step 2: Download the repository

git clone https://github.com/dedsec1121fk/DedSec

Git creates a new folder named DedSec in the Termux home directory and downloads the files from the public repository.

Step 3: Run the setup

cd DedSec && bash Setup.sh

Setup.sh handles the main installation process and the necessary dependencies. The first run may take a while, especially on an older device or slow connection. For large installations, it is useful to enable the "Keep screen on" option from the Termux menu so that the process is not interrupted when the screen turns off.

After installation

• Select Greek or English and save the language.
• Choose a simple list or numbered menu until you become familiar with the categories.
• Only adjust the prompt if you understand what change is being made to the shell configuration.
• Create the first backup via the Save DedSec Project option.
• Close Termux properly from the notification panel and open it again.
• On subsequent startups, you can use "e" for English or "g" for Greek menu, when fast startup is configured.

What a new user should know

The fact that a tool opens through a menu does not mean that all actions are risk-free. Scripts can create, move or delete files, install packages, open ports or temporarily expose a local service. Before each action, the user should read the description, the storage path and what exactly will be changed.

Public repositories also need to be audited. Having code on GitHub is not a guarantee of security in itself. It is good practice to check the README, license, change history, dependencies, and the code itself, especially when a script requests credentials, API keys, access to camera, microphone, location, or shared storage.

Python versions and Termux packages change. A script that worked months ago may need a different dependency or update. That's why it's better to diagnose the first real error gradually rather than constantly reinstalling the entire project.

Finally, Android places restrictions on background processes, network ports, and device access. Behavior may vary by manufacturer, Android version, and power saving settings. A tool that works on one device may need a different setting on another.

Who is it useful for?

The DedSec Project is primarily aimed at people who want to use Android as a real technical tool, not just a content consumption device. A student can practice basic Linux and Python commands. A novice developer can use Git, edit code, and run a local web server. An instructor can organize secure labs with dummy data. A more experienced user can consolidate frequent workflows into a portable environment.

It is not, however, a substitute for a full lab, a properly isolated virtual machine, or training in the fundamentals. The menu simplifies access, but does not eliminate the need for understanding. The greatest value of the project appears when it is used as a starting point: the user runs a tool, reads what it does, examines the code, and gradually learns to create or adapt their own solutions.

Conclusion

The DedSec Project shows that an Android phone can be much more than an application platform. With Termux as its foundation, it combines command-line tools, development, file management, local web applications, diagnostics, and educational security labs into a single environment.

Its strength is not that it replaces every specialized tool, but that it lowers the initial barrier. The user starts from an organized, bilingual menu, discovers what is possible, and then can delve deeper into Linux, Python, networks, and responsible cybersecurity.

With proper use, clear scope, code review, and respect for consensus, the project can function as a portable learning and creation laboratory. And perhaps this is the most interesting message: to start learning, one does not always need expensive hardware. Sometimes all that is needed is an Android phone, a terminal, and the willingness to understand what is happening behind the screen.

Official links

• DedSec Project website: https://ded-sec.space
• Official GitHub repository: https://github.com/dedsec1121fk/DedSec
• Installation guide: https://ded-sec.space/Pages/guide-for-installation.html
• Detailed presentation of tools: https://ded-sec.space/Pages/learn-about-the-tools.html
• Security policy: https://github.com/dedsec1121fk/DedSec/security

Note: The DedSec Project is an independent community project and is not officially affiliated with the creators of Termux or Ubisoft. Third-party names belong to their respective owners.