Progetti
🤖 Computer Vision & Artificial Intelligence
Multi-Object Tracking System (2026)
Independent design and development of an advanced computer vision architecture optimized for continuous tracking and real-time detection of dynamic entities (vehicles, cyclists, and pedestrians) within complex road video streams. The system integrates the YOLOv8 object detection model with the DeepSORT and ByteTrack tracking algorithms, implementing custom logic based on Kalman filters to preserve the persistence of unique identities (IDs) and avoid the problem of track fragmentation during partial occlusions, overlaps, or sudden changes in ambient brightness. The inference pipeline has been entirely optimized using FP16/INT8 quantization and subsequent model compilation using TensorRT, ensuring high frames per second (FPS) execution on edge hardware. The system also includes an algorithmic module for calculating derived spatial metrics, such as line crossing counts and vector velocity estimation of tracked subjects.
Advanced Facial Recognition and Anti-Spoofing (2026)
Independent engineering of a high-precision biometric facial recognition system, specifically enhanced to operate in challenging environments such as low background lighting, extreme angles, or partial facial occlusions. The application core leverages state-of-the-art deep learning architectures based on ArcFace and custom variants of ResNet, trained with advanced data augmentation pipelines (such as random cropping, color jittering, and blurring) to maximize the extraction robustness of vector feature embeddings. To ensure the system's intrinsic security against physical or digital injection attacks, a proprietary Liveness Detection (anti-spoofing) module was integrated, capable of distinguishing real faces from hacking attempts made via printed photos, 2D masks, or digital displays. The overall model was converted and serialized in the ONNX format, reducing inference latency and optimizing RAM/VRAM allocation, while maintaining a high True Acceptance Rate (TAR) and minimizing false positives (FAR).
AI Robotics Project - Real-Time Gestural Avatar (2026)
Development of a modular software ecosystem for real-time control of a robotic avatar based on the immediate replication of the operator's anthropomorphic gestures. The system leverages the MediaPipe libraries (Pose, Hands, and Face Mesh) to simultaneously and at high frequency map the nodal points of the body skeleton, finger joints, and facial contours detected by a single standard webcam stream. Using mathematical geometric transformation logic and advanced procedural rendering developed in OpenCV, the extracted movements are normalized with respect to the source perspective and instantly translated into the corresponding joints of the mechanical members and the animations of the avatar's digital expressions. The application is structured on a highly extensible Python plugin architecture, featuring a dual-view graphical interface that simultaneously displays the original video stream and the rendered behavior of the avatar, integrating an asynchronous recording module for analyzing motion logs and optimizing kinetic flows.
Drowsiness Detection System - Active Surveillance (2026)
Development of a real-time biometric monitoring application designed to prevent drowsiness and attention lapses during prolonged work sessions. Leveraging dlib's predictive models for extracting 68-point facial landmarks and OpenCV processing functions, the system performs a continuous mathematical calculation of the Eye Aspect Ratio (EAR) and Mouth Aspect Ratio (MAR) to geometrically assess eye-opening status and yawn frequency. A progressive alarm triggering logic based on moving time windows has been implemented: the system accurately distinguishes normal involuntary blinks from prolonged blinks caused by fatigue, triggering visual feedback on the GUI and asynchronous acoustic alerts (managed via the pygame library). The entire pipeline of computational and frame processing universes has been optimized at a low level to reduce computational overhead and ensure maximum execution fluidity even on machines without dedicated hardware acceleration.
🛡️ Cyber Security and Threat Analysis
Air Drawing Interface (2026)
Design of a gestural user interface (Natural User Interface) that allows interaction and drawing on a virtual canvas without any physical contact, using only hand movements in three-dimensional space. The application relies on the high-precision tracking provided by MediaPipe Hands to detect spatial geometry and the distance between fingers. A finite state machine was developed in Python to dynamically omit and recognize the user's intentions based on the relative proximity of landmarks (e.g., "writing" mode calibrated to the union of the index finger and thumb, "hovering" mode for free cursor movement, and "eraser" mode responsive to a closed fist). The application supports simultaneous multi-handed drawing, dynamic color palette selection, adjustable stroke width, and instant canvas screenshot saving in PNG format. It optimizes the stability of drawn lines by applying smoothing filters based on moving averages.
🛡️ Cyber Security and Threat Analysis
Core Shield Engine - Heuristic Antivirus Engine (2026)
Development in C++17 of a modular malware scanning engine based on a native multithreaded architecture, designed to maximize I/O performance during in-depth analysis of the Windows file system. The software implements a dual layer of protection: a deterministic detection module based on cryptographic signatures (SHA-256 securely extracted via Windows CryptoAPI) and an advanced heuristic analysis engine. The latter calculates Shannon entropy on binary files to identify the presence of encrypted, obfuscated, or compressed code typical of malware packers, while simultaneously checking the real extension by verifying Magic Numbers in file headers to block masking attempts. The system includes an automatic quarantine mechanism for suspicious items, concurrent file descriptor management to avoid race conditions, and the writing of tracking and telemetry logs in structured JSON format.
CyberSec Manager - Vulnerability Assessment Platform (2026)
Creation of a centralized web platform for mapping corporate assets and conducting automated vulnerability assessment activities. Developed in Python with the Flask microframework, the application interfaces at a low level with the Nmap engine through the execution of controlled asynchronous subprocesses, allowing targeted port scanning, service discovery, and OS detection to be initiated on the local network. Sensitive data stored in the database, including authentication keys and asset notes, is protected with end-to-end symmetric encryption (Fernet algorithm from the Cryptography library), while session security is handled by Flask-Login. The platform automatically calculates the host risk level (Low/Medium/High) by cross-referencing detected service banners with known vulnerability vectors on critical protocols, offering a responsive dashboard and an exportable audit history.
Software Supply Chain Analyzer (SBOM & Threat Intelligence - 2026)
Development of an automated DevSecOps flow-oriented security auditing tool to analyze the integrity of the software supply chain. The tool performs static parsing of project dependency files (such as requirements.txt, package.json, and Dockerfile) and asynchronously queries the OSV.dev and pip-audit vulnerability databases to detect known vulnerabilities (CVE). It includes advanced fuzzy matching algorithms to detect typosquatting attacks on package names and heuristic modules to analyze the reputation and activity of open-source repository maintainers. The tool automatically generates the application's Software Bill of Materials (SBOM), models dependencies using an interactive graph (NetworkX), and exports a final HTML report that ranks the countermeasures to be adopted based on remediation priority, in full compliance with the US Executive Order on cybersecurity.
Security Policy Analyzer - Web Security Assessment (2026)
Design of a web scanner oriented to analyzing the defensive configuration of web applications by checking their HTTP security headers. The application, equipped with a reactive Flask interface, makes controlled HTTP requests to target hosts and performs rigorous syntactic parsing of the received parameters, analyzing the robustness of key directives such as Content Security Policy (CSP), HTTP Strict Transport Security (HSTS), X-Frame-Options, and X-Content-Type-Options. The analytics engine identifies insecure configurations within CSPs (such as the permissive use of 'unsafe-inline' or wildcards) and intercepts information leakage caused by explicit server headers. Upon completion of the analysis, the system assigns an overall security score (score 0-100) and provides detailed contextual alerts with recommended configuration strings to mitigate Information Disclosure and Cross-Site Scripting (XSS) vulnerabilities.
Forensic Scanner in Python (2026)
Development of a command-line utility for digital forensics and file identification within raw data streams or logical disk images. The tool performs a sequential scan of the binary stream in optimized blocks, extracting file signatures (file signatures/magic bytes) to identify and reconstruct the actual file extension regardless of the stored file name. The software validates the structural integrity of the element by dynamically calculating MD5 and SHA-256 cryptographic hashes during the reading process, ensuring the immutability of the analysis source. All extracted metadata, detected timestamps, and block mapping are exported in a JSON-formatted report to ensure readability and interoperability with other forensic tools.
Autonomous UBA System (User Behavior Analytics - 2026)
Design of a security monitoring system based on user behavior analysis (User Behavior Analytics) that relies exclusively on unsupervised machine learning models. The software architecture is designed to self-train by analyzing corporate access log streams, isolating and correlating activity patterns without the need for prior manual data labeling (zero manual labeling). The model validated its effectiveness by processing a test dataset with over 1,000 complex events, successfully intercepting more than 77,000 behavioral micro-anomalies. Upon detecting significant deviations from the user baseline (such as unusual login times, anomalous simultaneous geolocations, or spikes in authentication failures), the system generates contextual security alerts ready for escalation to Incident Response teams.
Fake Login & Credential Stuffing Detection (2026)
Engineering a security module for web authentication infrastructures, aimed at distinguishing legitimate login attempts made by real users from automated credential stuffing campaigns orchestrated by botnets. The system is based on the statistical and temporal analysis of login requests directed to sensitive endpoints. By monitoring metrics such as form submission rate per session, user-agent variability, and simulated typing delays, the algorithm calculates a behavioral anomaly score in real time. If critical thresholds are exceeded, the system activates dynamic protective countermeasures (e.g., introducing restrictive rate-limiting, injecting CAPTCHA challenges, or temporarily blocking IP addresses at the application level), mitigating the impact of brute-force attacks before they can compromise customer accounts.
Security Log Analyzer (Log Analyzer - 2025)
Development of a Python security script focused on real-time monitoring and analysis of system authentication logs (e.g., Linux auth.log). The software continuously parses incoming text using optimized regular expressions (Regex), extracting failed SSH or application connection attempts and mapping them to the originating IP address. By implementing a configurable time threshold logic, the system instantly detects patterns attributable to brute-force attacks. When the alarm is triggered, the program sends immediate notifications to the system administrator and generates automated actionable recommendations, providing the exact syntax for inserting the malicious IP into network firewall rules (iptables) or direct integration with fail2ban custom jails.
Password Strength & Entropy Evaluator (2025)
Development of a CLI (Command Line) tool (ne Interface) written in Python and designed to scientifically evaluate the security of login credentials before storing them in corporate databases. The algorithm not only checks the minimum length, but also calculates the effective Shannon entropy of the string to measure its mathematical randomness. The software integrates heuristic modules to detect weak structural patterns, such as common alphabetic sequences, character repetitions, and the use of dictionary words. It also performs a local asynchronous comparison against blacklists of historical violations and public data breaches. The tool classifies the password within 4 strictly defined strength levels (from Weak to Very Strong), providing the user with immediate visual feedback and detailed technical suggestions for increasing the string's complexity.
Dockerfile Static Analyzer (Dockerfile Scanner - 2025)
Development of a modular static analyzer (linter) designed to verify the security posture of container images before being built in a production environment. The program's core parses the syntax of Dockerfiles to detect security anti-patterns and risky configurations, such as running internal processes with root privileges, unnecessary exposure of communication ports, use of outdated or missing versioned base images, and inadvertently storing hard-coded secrets or credentials in environment variables. The software is designed with a highly extensible plugin architecture, allowing security teams to easily integrate new compliance rules and include the scanner as a validation gate within Continuous Integration (CI/CD) pipelines.
TCP Port Scanner Educational (2025)
Development of a TCP port scanner in Python for educational and research purposes, focused on learning low-level network interactions. The program avoids the use of high-level libraries, relying exclusively on the direct use of the native socket library to manage packet manipulation and connection establishment (3-way handshake). The code implements multi-threaded scanning techniques to accelerate the analysis of authorized test hosts (e.g., scanme.nmap.org), intercepting and promptly managing network timeouts and operating system error responses. The project is extensively documented with theoretical insights into transport protocols, explicit ethical disclaimers on the correct use of security software, and guidelines for running tests in full compliance with current policies and regulations (GDPR and Article 615-ter of the Italian Criminal Code).