Introduction to Red Teaming: Understanding the principles, objectives, and methodologies of Red Team operations.

Exploitation, AV/EDR Evasion and Payload Delivery: Methods for breaching systems and deploying malicious payloads.

Privilege Escalation: Techniques to escalate privileges to Domain Admin

Lateral Movement and Pivoting: Techniques for moving through networks and escalating access.

Command and Control (C2) Operations: Setting up and managing remote access to compromised systems.

Hands-On Labs: Real-world attack simulations to test and refine skills in a safe environment.

Windows Internals & Malware Development: PE file format, API usage, and payload encryption.

Binary Signing & Trust Manipulation: Techniques for signing and bypassing trust mechanisms.

Process Injection: Shellcode runners, DLL injection, and advanced techniques like MockingJay.

AV/EDR Internals: Understanding detection mechanisms and basic evasion strategies.

Advanced Evasion & Bypass: Bypassing ETW, AMSI, and AV signature detection.

ETW & AMSI Bypass: Patch-based and patchless bypass techniques.

API Hooking: Manual inline hooking and using tools like Frida and Detours.

Advanced EDR Evasion: Unhooking, syscalls, and techniques like Perun's Fart.

Introduction to Penetration Testing: Overview of concepts, methodologies, and tools.

Reconnaissance and Information Gathering: Techniques for identifying potential targets and vulnerabilities.

Exploitation Techniques: Practical methods for exploiting system vulnerabilities.

Privilege Escalation: Strategies to gain higher-level access to compromised systems.

Post-Exploitation Activities: Maintaining access and extracting valuable information.

Reporting and Documentation: Best practices for communicating findings and remediation steps.

Hands-On Labs: Real-world scenarios to apply learned techniques in a controlled environment.

Introduction to Web App Penetration Testing: Overview of methodologies and tools.

Reconnaissance & Information Gathering: Techniques for mapping out web application attack surfaces.

Injection Attacks: Identifying and exploiting SQL injection, XXE, and command injection vulnerabilities.

Authentication & Session Management: Testing for flaws in login mechanisms and session management.

Java Deserialization Vulnerabilities: Exploiting insecure deserialization in Java applications.

File Upload & Remote Code Execution: Bypassing file upload restrictions and exploiting RCE vulnerabilities.

Security Misconfigurations: Identifying common web app misconfigurations and default settings.

Hands-On Labs: Real-world scenarios to practice web application attacks and defenses.

Introduction to DevSecOps: Overview of DevSecOps principles and practices.

GitLab CI/CD Pipeline Setup: Configuring GitLab pipelines for automated security testing.

Static Application Security Testing (SAST): Implementing and running SAST in GitLab for code analysis.

Dynamic Application Security Testing (DAST): Integrating DAST tools into the pipeline to test running applications.

Container Security: Securing Docker images and Kubernetes deployments using GitLab CI/CD.

Secret Management: Best practices for managing and securing secrets in GitLab.

Infrastructure as Code (IaC) Security: Automating IaC security checks within GitLab pipelines.

Hands-On Labs: Real-world scenarios for integrating security into DevOps with GitLab.

Introduction to Container Security: Overview of container security risks and defense strategies.

Docker Security Best Practices: Securing Docker images, containers, and the Docker daemon.

Kubernetes Security Fundamentals: Hardening Kubernetes clusters, nodes, and network policies.

Securing Container Images: Scanning, signing, and managing trusted container images.

Access Control & RBAC: Implementing Role-Based Access Control (RBAC) in Kubernetes.

Network Security in Kubernetes: Managing pod-to-pod communication, ingress, and egress controls.

Secrets Management: Protecting sensitive data within Docker and Kubernetes environments.

Hands-On Labs: Real-world scenarios for securing Docker and Kubernetes environments.

Introduction to Spring Boot: Overview of Spring Boot and setting up your first application.

Spring Boot Architecture: Understanding core components like Spring MVC, Spring Data, and Spring Security.

RESTful Web Services: Creating REST APIs with Spring Boot and integrating them with frontend applications.

Database Integration: Using Spring Data JPA for seamless database connectivity and management.

Security Best Practices: Implementing authentication and authorization with Spring Security.

Exception Handling & Validation: Managing errors and validating user input in Spring Boot applications.

Testing Spring Boot Applications: Writing unit and integration tests for Spring Boot applications.

Deployment & Scaling: Deploying Spring Boot applications to cloud platforms and scaling strategies.

Hands-On Labs: Real-world projects to build and secure Java web applications.

Introduction to Microservices Architecture: Overview of microservices principles and design patterns.

Building Microservices with Spring Boot: Setting up and developing Spring Boot-based microservices.

Service Communication: Implementing REST APIs and message brokers (RabbitMQ, Kafka) for inter-service communication.

Spring Cloud Integration: Using Spring Cloud for service discovery, configuration management, and load balancing.

Security in Microservices: Implementing authentication and authorization across microservices with Spring Security and OAuth2.

Testing Microservices: Writing unit and integration tests for microservices.

Deployment & Monitoring: Deploying microservices using Docker and Kubernetes, and setting up monitoring with Spring Boot Actuator.

Hands-On Labs: Real-world scenarios to build and deploy a microservices-based system.

Introduction to .NET Core: Overview of .NET Core and setting up your development environment.

Building Web APIs: Creating RESTful APIs with ASP.NET Core.

Entity Framework Core: Integrating databases using EF Core for data management.

Authentication & Authorization: Implementing security using ASP.NET Core Identity and OAuth2.

Middleware & Routing: Using middleware to handle requests and route them to controllers.

Dependency Injection: Leveraging DI for decoupling components and improving testability.

Testing .NET Core Applications: Writing unit and integration tests for .NET Core projects.

Exception Handling & Logging: Managing errors and logging with built-in tools.

Deployment & Scaling: Deploying .NET Core applications to cloud platforms like Azure.

Hands-On Labs: Real-world projects to develop and deploy .NET Core applications.