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:

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

Technologies

Java, Spring Boot, Angular, TypeScript, MongoDB, Docker, RabbitMQ, OpenNebula, Guacamole, OpenTelemetry

Engagement

FREELANCE

Timeline

2022-01 – Present