📋 Overview

This project is a cybersecurity honeypot deployed on AWS EC2 designed to attract, capture, and analyze SSH brute-force attacks from around the world. By deploying Cowrie — a medium-interaction SSH honeypot — the system simulates a realistic Linux environment, logging attacker credentials, connection patterns, and post-compromise behavior.

All captured data is fed into a Wazuh SIEM (Security Information and Event Management) system for centralized log collection, correlation, and analysis. The result is a comprehensive Global Attack Map — an interactive dashboard that visualizes attack origins, frequencies, and patterns in real-time.

🏗️ System Architecture

⚡ Key Features

• Cowrie Honeypot — Medium-interaction SSH/Telnet honeypot simulating a realistic Linux environment for attacker engagement
• Wazuh SIEM Integration — Automated log collection, rule-based alerting, and security event correlation
• Global Attack Map — Interactive dashboard visualizing attack origins via GeoIP data and attack frequency patterns
• Credential Analysis — Captures and catalogs attempted username/password combinations for threat intelligence
• Real-time Monitoring — Live feed of incoming attacks with geographic mapping and statistical analysis
• Post-Compromise Tracking — Cowrie captures commands executed by attackers, providing insight into common attack methodologies

🔧 Technology Stack

🎯 Goals & Objectives

• Build a comprehensive understanding of real-world SSH brute-force attack patterns
• Create an educational tool for demonstrating the scale and persistence of automated attacks
• Develop threat intelligence capabilities through data analysis and pattern recognition
• Gain hands-on experience with SIEM deployment, log correlation, and security monitoring
• Eventually integrate ML-based anomaly detection for predictive threat analysis

📋 Overview

This project focuses on the local deployment and optimization of Large Language Models (LLMs) using llama.cpp — a highly efficient C/C++ inference library. The goal is to maximize inference performance while minimizing the computational and memory resource footprint, enabling LLMs to run efficiently on consumer-grade hardware.

The project explores various quantization techniques (GGUF format), hardware acceleration options (CPU, GPU, Metal, Vulkan), and model selection strategies to create an efficient, production-ready local AI workflow.

🏗️ System Architecture

🔬 Research Areas

• Quantization Techniques — Exploring GGUF formats (Q2_K through Q8_0) to find the optimal balance between model quality and resource efficiency
• Hardware Acceleration — Benchmarking CPU-only inference vs. GPU acceleration (CUDA, Vulkan, Metal) for different model sizes
• Memory Optimization — Minimizing VRAM/RAM usage through layer offloading, KV cache optimization, and batch size tuning
• Inference Performance — Measuring tokens-per-second across different configurations, model architectures, and quantization levels
• Model Selection — Comparing different open-source LLM architectures (Llama, Mistral, Phi, etc.) for specific use cases
• API Integration — Setting up OpenAI-compatible API servers for seamless integration with existing applications

🔧 Technology Stack

📊 Quantization Comparison

🎯 Goals & Objectives

• Establish an efficient local AI workflow that runs complex LLMs on consumer hardware
• Document quantization benchmarks for different model architectures and sizes
• Create a reproducible setup for running open-source LLMs with minimal resource overhead
• Explore the potential of local LLMs for automated security analysis and reporting
• Eventually integrate the LLM into the Wazuh project for automated threat analysis

📋 Overview

This project involves developing a positioning system for tracking carts in a warehouse/retail environment. The system uses ESP32 microcontrollers as WiFi signal receivers to determine cart locations, with data processed and displayed through a Django web application.

The architecture was designed using Use Case (UC) diagrams and Entity-Relationship Diagrams (ERD) to ensure a well-structured and scalable system design.

⚡ Key Features

• ESP32 Sensor Network — Multiple ESP32 devices deployed as WiFi signal receivers for cart position triangulation
• Django Web Dashboard — Real-time monitoring interface showing cart locations and movement history
• System Architecture — Professional design using UC diagrams and ERD schemas for clear system structure
• C++ Embedded Code — Low-level firmware for ESP32 devices handling WiFi scanning and data transmission
• Python Backend — Django framework powering the web application with database integration and API endpoints

🔧 Technology Stack

📋 Overview

A fully configured FreeBSD server leveraging the operating system's native strengths: openZFS for enterprise-grade storage with raidZ2 redundancy, and Jails for lightweight, secure containerization. The server runs multiple services including FTP, SFTP, OpenVPN, and Plex Media Server.

⚡ Key Features

• openZFS raidZ2 — Double-parity RAID configuration for maximum data protection
• FreeBSD Jails — Lightweight isolation for running services securely
• FTP / SFTP — File transfer services with proper access controls
• OpenVPN — Secure remote access VPN tunnel
• Plex Media Server — Media streaming service for personal media library

🔧 Technology Stack

📋 Overview

A fully custom Arch Linux installation performed manually — from disk partitioning to desktop environment configuration. Every package and service was hand-selected and tuned for maximum productivity and minimal resource consumption.

This project demonstrates deep Linux knowledge, from understanding the boot process to configuring networking, services, and a personalized development environment.

⚡ Key Features

• Manual Installation — Full disk setup with partitioning, filesystem creation, and bootloader configuration
• Custom Configuration — Every service and package hand-tuned for optimal performance
• Productivity Workflow — Development tools, terminal customization, and automation scripts
• System Hardening — Security best practices applied from the ground up
• Rolling Release — Leveraging Arch's rolling release model for always-up-to-date software