I just published Deception Mesh, an open-source cybersecurity MVP built in Rust.
Project page: https://tucodigocotidiano.yarumaltech.com/proyectos/deception-mesh/
GitHub: https://github.com/tucodigocotidiano/deception-mesh
Why I built it
Most small projects and learning environments think about security only after something goes wrong.
Firewalls, authentication and monitoring are important, but there is another useful defensive idea:
What if we could deploy small decoy services that are not real production systems, but can help us observe suspicious behavior?
That is the core idea behind Deception Mesh.
Instead of exposing only real services, the project uses lightweight decoy sensors that can capture suspicious HTTP and SSH activity and turn it into structured telemetry.
What Deception Mesh does
Deception Mesh is a defensive MVP.
It is not an offensive tool.
It does not try to exploit systems.
It does not provide attack automation.
Its purpose is to help observe suspicious interactions against decoy services and make those events easier to inspect.
The MVP includes:
- HTTP decoy sensor
- SSH decoy sensor
- REST API
- JWT authentication
- Role-based access control
- Webhook notifications
- CSV export
- Docker deployment
- Documentation for local execution and testing
The technical idea
The project is based on a simple flow:
- A suspicious client interacts with a decoy service.
- The sensor captures the event.
- The system stores or exposes the event as structured telemetry.
- The operator can review the signal through logs, CSV exports, API responses or webhook notifications.
The goal is not to replace enterprise security platforms.
The goal is to show that a small, understandable and auditable deception layer can be built with practical software engineering.
Why Rust
I chose Rust because it is a strong fit for infrastructure-oriented security projects.
It gives a good balance between performance, memory safety and explicit design.
For a project that handles network-facing components, Rust also encourages discipline around error handling, data structures and system boundaries.
What I wanted to prove
With this MVP, I wanted to validate four things:
- A deception-based security concept can be implemented without building a huge platform.
- Rust can be used to create small defensive sensors with clean architecture.
- Security telemetry can be made understandable for developers and students.
- A project can be useful even when its scope is intentionally limited.
That last point matters.
This is not presented as a finished commercial product.
It is a validated MVP with a clear defensive scope and room for improvement.
Who this project is for
This project may be useful for:
- Software engineering students
- Cybersecurity students
- Backend developers
- Rust learners
- People interested in defensive infrastructure
- Anyone curious about deception-based security
It can also be a starting point for discussions around telemetry, detection, infrastructure hardening and practical security engineering.
Current limitations
The project is intentionally honest about its current stage.
It is an MVP.
It still needs more hardening, better testing, stronger deployment guidance and deeper validation before being treated as production-ready.
That is part of the reason I am publishing it openly.
I want feedback, technical criticism and ideas from people who care about building useful defensive systems.
Final thoughts
Deception Mesh started as a practical experiment, but it became a valuable learning project around cybersecurity, Rust, backend systems and telecommunications.
If you are interested in open-source cybersecurity, defensive telemetry or Rust-based infrastructure, I would be happy if you take a look.
GitHub: https://github.com/tucodigocotidiano/deception-mesh
Feedback, issues, stars and technical suggestions are welcome.
Top comments (0)