CITEF — Cyber Range and Virtual Lab Platform
Summary
CITEF creates virtual lab environments for cybersecurity training and makes them reachable from the browser, with access limited to what each participant should see. My part is mostly the backend: provisioning, access rules, remote sessions and the integrations behind them.
Subtitle
Isolated virtual labs and browser-based remote access for cybersecurity training.
Domain
Cybersecurity / Virtual labs / Remote access
Target users
Instructors, exercise operators, administrators and trainees who need safe, isolated environments for hands-on cybersecurity work.
Role
Senior Backend Engineer / Java Consultant
Challenge
Training platforms like this have many moving parts: virtual machines, networks, users, permissions and remote sessions. The hard part is not starting a VM, it is making sure the right person gets to the right machine at the right time, and that operators stay in control while it happens.
What I owned
Backend design and implementation, API and domain model, integrations with OpenNebula, Guacamole and Keycloak, remote access flow, simplification of infrastructure code, Angular work where needed, and input on architecture and operations.
Approach
Keep identity, sessions, infrastructure and application logic as separate concerns, treat remote access as part of the user flow, and remove infrastructure options nobody needs.
Outcomes
Trainees open a scenario and connect to their machines from the browser in a few clicks, while access rules, sessions and infrastructure are handled by the backend. The codebase has fewer special cases and better diagnostics, which makes new scenarios and integrations cheaper to add.
Details
Overview
CITEF is a training platform for cybersecurity courses and exercises. An instructor picks a scenario, the platform builds the virtual machines and networks for it, and every participant gets browser access to the machines assigned to them, nothing more.
I joined in 2022 as a senior backend engineer through my consultancy and have worked on it since, mostly on the Java side and occasionally on the Angular frontend.
The problem
From the trainee's point of view the platform should feel simple: open the exercise, click a machine, start working. Underneath, every click touches several systems:
- Keycloak decides who the user is and what they may do
- OpenNebula holds the virtual machines and their state
- Apache Guacamole delivers RDP, VNC and SSH sessions to the browser
- the backend ties scenarios, permissions and sessions together
The real difficulty is keeping that coordination predictable as scenarios, users and infrastructure options grow.
Architecture
flowchart TD
A[Angular Client] --> B[Java / Spring Boot Backend]
B --> C[Keycloak]
B --> D[OpenNebula]
B --> E[Guacamole]
B --> F[MongoDB]
B --> G[RabbitMQ]
D --> H[Virtual Machines]
E --> I[RDP / VNC / SSH Sessions]
B --> J[Scenario / Access / Session Logic]
The rule I tried to follow: keep identity, sessions, infrastructure and scenario logic in separate places, so that a change in one does not ripple through the others.
Opening a remote session
sequenceDiagram
participant U as User
participant UI as Angular UI
participant API as Backend API
participant IAM as Keycloak
participant IaaS as OpenNebula
participant REM as Guacamole
U->>UI: Open assigned training scenario
UI->>API: Request scenario and access details
API->>IAM: Validate identity and permissions
IAM-->>API: User authorized
API->>IaaS: Resolve lab resources / VM state
IaaS-->>API: Resource details
API->>REM: Prepare remote connection/session
REM-->>API: Connection metadata
API-->>UI: Return access information
U->>UI: Launch remote session
For the user this is one click. For the backend it is a permission check, a lookup of the machine's state and a short-lived Guacamole connection prepared for that user only.
Decisions that mattered
Remote access is part of the product, not an add-on. Connections are modelled together with scenarios and permissions, so the UI, the access rules and the session handling all agree on who can open what.
Clear boundaries over clever abstractions. Identity, session handling, infrastructure and application logic live behind separate interfaces. Most bugs became easier to locate once that was true.
Less flexibility where nobody uses it. The code had grown branches for several infrastructure directions. Removing the ones that were not used made the remaining paths simpler to test and reason about.
Visibility in production. Lab sessions can run for hours. OpenTelemetry tracing and better diagnostics make it possible to follow a single user's request across services when something goes wrong.
Result
Participants get to their machines quickly, operators keep control over environments and access, and the team has a backend that is easier to extend than when I joined.
Next steps I'd prioritise
- finer-grained permission and visibility rules
- reusable session and tunnel management
- more admin views for diagnostics
Technologies
Java, Spring Boot, Angular, TypeScript, MongoDB, Docker, RabbitMQ, OpenNebula, Guacamole, OpenTelemetry
Engagement
FREELANCE
Timeline
2022-01 – Present