SLAIT — Secure Language Assembly Inspector Tool
Overview
SLAIT (Secure Language Assembly Inspector Tool) is a senior design project focused on making low-level code inspection safer and more accessible for students and developers working with assembly and other low-level languages.
In many computer architecture and systems courses, students are required to run and debug assembly code locally. This often involves lowering system protections or executing unsafe binaries, which can put a personal machine at risk. SLAIT addresses this problem by providing a secure, sandboxed execution environment that allows users to inspect register and flag behavior without running untrusted code on their own device.
How SLAIT Works (High Level)
Users interact with SLAIT through a web interface where they:
- Paste or upload assembly code
- Specify which registers they want to observe
- Choose the exact lines of code where those registers should be tracked
Behind the scenes, SLAIT:
- Spins up a Docker-based sandbox
- Assembles and links the code using NASM and GCC
- Uses GDB to set breakpoints and capture register state
- Returns structured output to the frontend for visualization
All execution happens inside the sandbox, keeping the user’s system isolated from potentially unsafe behavior.
My Role — Backend & Execution Environment
I am primarily responsible for designing and implementing the backend execution environment for SLAIT.
My work includes:
- Designing the Docker sandbox image used to execute user-submitted code
- Building the execution pipeline that assembles, links, runs, and inspects assembly programs
- Implementing GDB-based register tracking, including support for:
- Multiple breakpoints
- Per-line register selection
- Ensuring that execution artifacts remain isolated and reproducible
- Designing the container lifecycle so that each request runs in a clean, disposable environment
Rather than mounting host directories directly, the current architecture copies user input into the container, executes everything internally, and then extracts only the required output. This keeps the system safer and avoids host permission issues.
Current Progress
At this stage, the backend pipeline is fully functional in isolation:
- ✅ Docker sandbox builds successfully
- ✅ User assembly files and configuration files can be copied into a container
- ✅ Code is assembled, linked, and executed inside the container
- ✅ GDB captures register values at multiple specified lines
- ✅ Output files are generated in a consistent, structured format
- ✅ Containers can be cleaned up automatically after execution
The next phase of development will focus on:
- Integrating the backend pipeline with the frontend via HTTP requests
- Returning execution results in a format suitable for visualization
- Finalizing security and cleanup mechanisms
Why This Project Matters
SLAIT sits at the intersection of systems programming, security, and tooling. It solves a real problem faced by students learning low-level programming while also reinforcing best practices around sandboxing, isolation, and safe execution.
For me personally, this project has been a deep dive into:
- Containerized execution
- Debugging internals
- Toolchain automation
- Secure system design
It’s been one of the most technically rewarding projects I’ve worked on so far.
More updates will be added as the project moves toward full frontend integration and final deployment.