cover photo

COURSE

CL-CY-001

4 Levels · 6 Months

Introduction to Cloud Computing and Cyber Security

CL-CY-001

Jump to:


Level 1


Generic Tasks

Task 1: Print It Yourself

Design a Simple Part and 3D Print It

First learn how a 3D printer works. Then design your own simple parts, a cube and a cylinder, in Onshape. It runs in your browser, so there is nothing to install. No CAD experience needed, so students from any branch can do it. After that, slice your design and print it.

Objective: Know the full process of 3D printing: design, STL file, slicing and printing.

What to do

  1. Watch the intro video on 3D printers and read the PLA settings guide.
  2. Go through the 3D printer SOPs.
  3. Make an Onshape account with your college email.
  4. Read the Onshape article below. Design a cube (30 mm sides) and a cylinder (30 mm diameter, 30 mm height) as two separate parts.
  5. Export them as an STL file in millimeters.
  6. Slice the STL in Bambu Lab studio. Note down the bed temperature and infill density.
  7. Print it with a coordinator present.

Learning Resources

Suggested Focus

Read the Onshape article first, then start designing. Type mm after every number. Keep the cube and cylinder as separate parts. Check that the STL is in millimeters before slicing.

Note: Printing is done only with a coordinator presence.


Task 2: Dynamic Portfolio & Admin Dashboard

Task Description

Design and develop a dynamic personal portfolio website along with an administrative dashboard that allows the portfolio owner to manage website content through a graphical interface without modifying the source code.

The application should consist of two integrated interfaces:

  1. A public portfolio website that showcases the student's profile, skills, projects, and achievements.
  2. An admin dashboard that allows the owner to manage and update portfolio content dynamically.

Requirements

1. Public Portfolio

  • Develop a responsive website displaying the student's profile, skills, projects, and achievements.
  • Retrieve and display portfolio content dynamically through an API.
  • Ensure that changes made through the admin dashboard are reflected on the public portfolio.

2. Admin Dashboard

  • Create a user-friendly administrative interface for managing portfolio content.
  • Implement functionality to add, view, update, and delete projects and skills using forms and controls.
  • Ensure that content management does not require direct modification of the source code.

3. REST API Development

  • Develop and integrate a RESTful API to facilitate communication between the admin dashboard, backend, and public portfolio.
  • Implement appropriate API endpoints and HTTP methods for creating, retrieving, updating, and deleting portfolio content.
  • Exchange data using JSON and implement basic input validation and error handling.

4. Data Management

  • Store and manage portfolio content using an appropriate in-memory data structure or another beginner-friendly mechanism.
  • Ensure that both the public portfolio and admin dashboard access the same application data.
  • Database integration is not required.

5. Deployment and Documentation

  • Deploy the application using suitable hosting platforms.
  • Maintain the source code in a GitHub repository.
  • Document the application architecture, API endpoints, setup instructions, and known limitations in a README file.

Expected Outcomes

  • Understand the development of dynamic and responsive web applications.
  • Learn the fundamentals of REST APIs, HTTP methods, and JSON.
  • Understand CRUD operations and client-server communication.
  • Gain experience integrating frontend interfaces with an API.
  • Develop skills in application deployment, documentation, and error handling.

Suggested Technologies

HTML, CSS, JavaScript, and any suitable backend technology or framework of the student's choice.

Submission Requirements

  1. Public portfolio website URL.
  2. Admin dashboard URL or route.
  3. GitHub repository link.
  4. README documentation.
  5. Screenshots demonstrating content management and dynamic updates.

Resources

  1. MDN: Getting Started with Web Development
  2. Postman: Getting Started Quick Start
  3. MDN: Network Requests

Task 3: Working with GitHub

Familiarize yourself with real-world Git and GitHub workflows including Issues, Branching, Resolving Merge Conflicts, Pull Requests, and GitHub Actions (CI/CD).

Given below is the task repository. Follow the instructions in its README.md to generate your username-specific assignment, document the bugs you find in a GitHub Issue, fix them on a new branch, resolve the practice merge conflict, and open a Pull Request.

What to include in your task report:

  1. The output of python my_task.py showing your assigned functions.
  2. A link to the GitHub Issue you opened and a brief explanation of the bugs you fixed.
  3. A link to your Pull Request showing the passing GitHub Actions check (Note: PRs are verified by CI and left open for review they do not need to be merged).

Check this link for more info: https://github.com/UVCE-Marvel/git-task


Task 4: Hack the hardware

Objective: Ubuntu Command Line: Systems Computing, Architecture & Linux

Core Intention

To move beyond rote command memorization and cultivate a deep, foundational understanding of computing systems, the Linux operating system, and system-level problem-solving. Students learn how and why their terminal commands navigate the software stack—from high-level shell calls down to execution units in hardware.

1. Hardware Foundation & Architecture: "The 'U' in CPU"

Topics & Concepts

  • The Anatomy of the CPU: The Control Unit (CU), Arithmetic Logic Unit (ALU), internal registers (A, D, Program Counter PC), and bus connections.
  • The Fetch-Decode-Execute Cycle: How machine instructions are fetched from memory, decoded by control logic, executed inside the ALU, and written back to registers/RAM.
  • Hardware Abstraction: How shell instructions translate through compiler/assembler pipelines into binary micro-operations that flip physical logic gates.

Why You Need This

Understanding hardware abstraction stops you from treating the terminal as a black box. Knowing how registers, memory addresses, and execution cycles work allows you to diagnose performance bottlenecks, manage low-level system resources, write efficient code, and program embedded microcontrollers or microprocessors effectively.

How to Study This Topic

  1. Nand2Tetris Unit 4 (Machine Language): Write assembly programs for the Hack computer (Mult.asm and Fill.asm) to manually track register states (A, D, M), instruction decoding, and memory-mapped I/O (Screen and Keyboard).
  2. Trace Hardware Metrics via Terminal: Use terminal utilities like lscpu, lsscsi, and cat /proc/cpuinfo to map abstract CPU concepts (cores, threads, cache sizes, architecture flags) to physical host hardware.

2. Operating Systems, Kernels, and Linux Distributions

Topics & Concepts

  • The Operating System's Core Role: Memory virtualization, process scheduling, storage management, and hardware safety.
  • What is a Kernel? The privileged (Ring 0) bridge between user space applications and physical hardware via System Calls (syscalls).
  • Linux Distributions vs. The Kernel: Distinguishing between the upstream Linux kernel and distributions (Ubuntu, Debian, Fedora, Arch) that package userland tools, package managers, and display servers.

Why You Need This

When a application or script crashes, hangs, or fails to start, the issue usually lies in kernel-level resource access, missing dependencies, or system call errors. Understanding OS mechanics enables you to debug real-world server, embedded Linux, and edge-computing environments.

How to Study This Topic

  1. System Call Observation: Run simple terminal commands through strace (e.g., strace ls) to observe how userland utilities request kernel services (e.g., openat, read, write).
  2. Virtual Filesystem Exploration: Navigate /proc and /sys to understand how the Linux kernel exposes running system states directly as text files.

3. The Linux Environment & Core System Concepts

Topics & Concepts

  • Terminal vs. Shell: Distinguishing between terminal emulators (user interface) and shells (bash, zsh — command interpreters).
  • Filesystem Hierarchy Standard (FHS): Root (/), user space (~), device files (/dev), configuration files (/etc), and system binaries (/bin, /usr/bin).
  • Permissions & Security Model: Read, write, execute (rwx) flags, file ownership (user:group), and privilege escalation (sudo).
  • Processes & Signals: Process IDs (PIDs), job control (&, fg, bg), environment variables, standard streams (stdin, stdout, stderr), and piping (|).

Why You Need This

The command line is the primary interface for remote servers, cloud infrastructure, robotics platforms (like ROS 2), and build environments. Mastering streams, permissions, and process controls lets you automate complex workflows and manage systems without relying on a graphical user interface.

How to Study This Topic

  1. Interactive Terminal Scenarios: Solve practical system issues (e.g., permission-denied errors, locating run-away processes with top or ps aux, killing stuck tasks via signals).
  2. Pipe Construction: Practice stringing fundamental tools (grep, awk, sed, cut, sort) together to parse logs and extract target metrics.

4. Practical Tips for Terminal Execution

  • Read the Manual (man): Never guess command flags. Run man (or use tldr ) to inspect flags and syntax.
  • Inspect Exit Codes: Check $? immediately after running a command to see if it succeeded (0) or threw an error (non-zero).
  • Fail Fast & Safely: Use ls or echo to verify wildcard patterns (e.g., echo *.log) before executing destructive commands like rm *.log.
  • Understand Standard Streams: Treat stdout (1) and stderr (2) separately so you don't miss error messages when redirecting logs.
  • Leverage Autocompletion & History: Use Tab key completion to avoid typos and Ctrl + R to search previous command history quickly.

5. Hands-on Problem Statement: System Audit & Log Processing Pipeline

You are tasked with inspecting a remote Linux workstation that has experienced intermittent slowdowns. Without using any Graphical User Interface (GUI), complete the following steps using terminal utilities:

  1. Hardware & Kernel Inspection: Identify the total number of physical CPU cores, architecture model, and the running Linux kernel version. Output these values into a file named system_summary.txt.
  2. Process & Resource Triage: Locate all running processes consuming memory on the system. Filter out system daemons to find the process ID (PID) of the process running under your user space, and write the output to process_audit.log.
  3. Permission & File System Reorganization:
    • Create a secure directory structure under ~/workspace/audit_logs/.
    • Change the directory permissions so that only your user has read, write, and execute permissions (700). Move all generated log files into this directory.
  4. Log Data Parsing & Filtering: Given a system log file containing mixed informational and error entries, write a single-line command pipeline using cat, grep, awk, and sort to extract only unique [ERROR] messages and count their occurrences.

6. What You Must Build

To successfully complete this task, you must build and deliver:

  1. Draw ur own Architecture: So draw how u think the CPU used to look before going through it and how it looks now according to u. Wrong answers welcomed but want to see ur understanding.
  2. Custom Automated Shell Script (system_health.sh): A bash script that gathers system uptime, CPU core count, active memory usage from /proc/meminfo, and active user processes, formatting them into a readable text report.
  3. Execution & Analysis Log Notebook: A written document explaining:
    • The step-by-step resolution of the Problem Statement.
    • Annotations of key strace outputs showing at least two system calls (openat, write).
    • Explanations for why specific piping choices (|) were used during log extraction.

7. Foundational Command-Line Exercises

  • Navigation & Inspection: pwd, cd, ls -la, tree
  • File & Directory Operations: touch, mkdir -p, cp -r, mv, rm -rf
  • Content Viewing & Inspection: cat, less, head, tail -f, echo, grep

8. Resource Links

Computer Architecture & Nand2Tetris

Linux & Command Line Fundamentals

  • The Linux Command Line by William Shotts (Free PDF): Comprehensive reference covering basic shell operations, environment management, and shell scripting.
  • Linux Journey: Interactive, modular guide breaking down Linux command line operations, text manipulation, permissions, process handling, and kernel mechanics.
  • LinuxCommand.org Tutorials: Structured, step-by-step tutorials on command execution, storage navigation, and terminal problem-solving.
  • TLDR Pages: Community-driven, simplified man pages focusing on practical, real-world command usage examples.

Task 5: Operation Blackout

Decode the Hidden Message

An unknown source has transmitted a mysterious sequence of numbers, and your mission is to uncover the secret hidden within it. The data may appear random, but with the right transformations, a meaningful pattern will emerge.

Using NumPy, investigate the encoded array, reshape it into a square matrix, experiment with transposing and reversing its elements, and visualize the result using Matplotlib. Follow the cryptic clues, piece together the original arrangement, and reveal the hidden message!

Can you crack the code and complete Operation Blackout?

Download the Numpy Array: https://drive.google.com/file/d/1lbzxfFuLJSNRXZqT63z8teFWCT44xfRk/view?usp=drivesdk

Learning Resources

NumPy

Matplotlib

YouTube Videos

Suggested Focus

Before solving the puzzle, review array size and shape, reshape(), transpose(), slicing, and reversing with negative-step slices. Then review imshow() and colormaps. Check that the number of array elements matches the target matrix dimensions before reshaping.

Note: The resources are supplementary learning materials. Students should understand and explain the transformations and model operations used in their own solutions.


Task 6: Build Your Own Brain

Linear Regression from Scratch

In this task, you will implement a Linear Regression model from scratch using NumPy to develop a deeper understanding of the underlying principles of machine learning. Using the California Housing dataset, you will train your model using Gradient Descent, investigate the effects of learning rate and feature scaling, and visualize the model’s learning process.

You will then compare your implementation with sklearn.linear_model.LinearRegression using standard evaluation metrics, including MSE, MAE, and R². Through this comparative analysis, you will gain practical insights into model optimization, performance evaluation, and the advantages of established machine learning libraries.

Objective: Develop a fundamental understanding of Linear Regression by implementing, evaluating, and comparing a custom model against a standard library implementation.

Learning Resources

Concepts and implementation

YouTube Videos

Suggested Focus

Start with the linear regression and gradient descent videos before coding. Then implement the model using NumPy, standardize features using training data only, and compare both models on the same held-out test set. Plot the loss over iterations and compare MSE, MAE, and R².


Task 7: Resource Article writing using Markdown

Markdown is an easy-to-use markup language that is used with plain text to add formatting elements (headings, bulleted lists, URLs) to plain text without the use of a formal text editor or the use of HTML tags. Markdown is device agnostic and displays the writing format consistently across device type. Write a technical resource article on a topic of your choice and post it on the MARVEL website. Refer to the linked article for further details.

LINK: https://hub.uvcemarvel.in/article/52f92f36-fb8a-45da-8f28-686bf4efefff


Task 8: Arduino vs ESP32

NOTE - Before working on this task it is mandatory to have read the basics of Arduino Uno and ESP32 task. Without finishing that do not work on this task.

Arduino UNO vs ESP32: Sensor-Based DC Motor Control

Problem Statement

Build a DC motor control system using Arduino UNO R3 and ESP32 to compare their pin configurations, analog inputs, PWM control, and voltage levels. Use an HC-SR04 ultrasonic sensor to measure distance and a potentiometer to control motor speed through a suitable motor driver. The motor must stop when an object comes closer than a predefined distance of 15 cm. Implement the same basic setup on both boards, ensuring that all sensor signals are compatible with the selected board. Finally, extend the ESP32 setup with a web page that allows users to control motor speed using a slider and stop the motor using a button. Identify what additional hardware the Arduino UNO would need to support similar Wi-Fi control.

Tips - Before working on hardware make a simulation for better understanding:

  1. For arduino uno use Tinkercad a beginner friendly web based software for electronics.
  2. For ESP32 use Wokwi simulation another web based software for electronics.

Why You’ll Need This

Arduino UNO and ESP32 can perform similar tasks, but their pin configurations, voltage levels, analog inputs, PWM capabilities, and wireless features differ. A circuit that works on one board may need changes before it can work safely on the other.

Through this task, you will explore these differences by building and testing the same application on both boards. You will also learn why a sensor powered by 5 V may require voltage conversion before its output can be connected to the ESP32's 3.3 V GPIO, and how PWM can be used to control motor speed.

What You Must Build

  1. Sensor and motor control: Connect the HC-SR04, potentiometer, and DC motor through a suitable motor driver. Use the potentiometer to vary motor speed and display distance readings on the Serial Monitor. The motor must stop when an object is detected within 15 cm.
  2. Implement on both boards: Build and test the same basic system using Arduino UNO R3 and ESP32. Identify the required pins and adapt the wiring and code for each board.
  3. Check voltage compatibility: Determine the voltage requirements of each component. Use suitable voltage-conversion circuitry for the HC-SR04 Echo signal when connecting it to the ESP32, and ensure the potentiometer output stays within the board's permitted input voltage.
  4. Add web-based control: Extend the ESP32 program with a web page containing a speed slider from 0% to 100% and a Stop button. The web interface must control motor speed, while the distance-based stop condition must override the selected speed.
  5. Compare the boards: Document the differences you observed in pin usage, analog readings, PWM implementation, voltage compatibility, and Wi-Fi setup. Explain what additional compatible hardware would be required to provide similar web-based control using Arduino UNO R3.

Learn Before You Build

  1. Arduino — PWM Output Guide and ESP32 — PWM Documentation to understand and compare PWM control.
  2. Voltage Divider Tutorial to learn how to reduce a sensor's output voltage safely.

For web servers:-

  1. https://randomnerdtutorials.com/esp32-web-server-slider-pwm OR
  2. https://randomnerdtutorials.com/esp32-web-server-dc-motor-arduino

Work through these resources before starting the implementation. Test the basic circuit on both boards first, then add web-based control to the ESP32. Record your observations and explain the differences you discover.


Task 9: The “Joint” Venture - Soldering

What are you required to do ?

  1. Go around the soldering station, look at all the equipment and try to figure out what they do and what they are.
  2. Gather your domain batchmates and get a one-time briefing from any of your domain coordinators on this task.
  3. Solder a simple circuit (Led Fader Circuit) on a perf-board. To be done Individually.
    • Video Guide: UVCE MARVEL : Soldering on perfboard
    • Circuit link: Tinkercad LED Fade Circuit
    • Refer to the above link for circuit connections.
    • Oscilloscope is optional but using it would get you additional credit points.
    • Components you’ll be requiring = 1nos 100 micro farad capacitor, 1nos 1K resistor, 1nos 10k resistor, 1nos generic PN junction diode, 1nos LED of your choice, 1nos pushbutton (do not use any other kind of switches) and Power supply rated anywhere from 5V - 9V.
    • Check the working of the circuit.
    • Wiring should be done using single stranded wires.
    • Tinning is an advisory method while soldering wires, as it assures contacts are stable and not loose.
  4. Theoretical knowledge buildup - Composition of Solder wire, flux.
  5. Types of board - PCB, BreadBoard, ZeroPCB (Perfboard):
  6. Hazards and Safety measures of Soldering. Resource : https://youtu.be/AqvHogekDI4?si=GofaPrza3gG6vJOZ

Task 10: VRPS, OSCILLOSCOPE

Soon


Task 11: 555 Astable Multivibrator with 60% Duty Cycle

Objective

Design, build and measure a 555 astable multivibrator. By the end you should be able to:

  • Choose the timing resistors and capacitor for a target frequency and duty cycle.
  • Wire the NE555 as an astable oscillator on a breadboard.
  • Measure frequency, high time and duty cycle on a digital storage oscilloscope (DSO).
  • Explain any gap between the designed and the measured values.

The Task

Design a 555 astable multivibrator whose output has a 60% duty cycle, build it on a breadboard, and observe the output on a DSO using the probes.

Pick a target frequency of 1 kHz so the waveform is easy to read on the scope (use another frequency only if your lab specifies one).

Steps

  1. Read first. Go through the resources below until you can write the astable formulas for frequency and duty cycle in terms of R₁, R₂ and C, and explain what charges and discharges the capacitor in each half of the cycle.
  2. Design on paper. From the target frequency and 60% duty cycle, work out the ratio of R₁ to R₂, then choose C and compute the resistor values. Show every step.
  3. Pick real parts. Round your resistors to standard values from the kit and recompute the frequency and duty cycle you will actually get.
  4. Build. Wire the NE555 on the breadboard with a 5 V to 12 V supply, your R₁, R₂ and C, and a small capacitor (about 10 nF) from the control pin to ground. Check the datasheet pinout before powering up.
  5. Probe. Connect the DSO probe to the output pin and ground. Set the timebase so that 2 to 3 full periods are visible, and make sure the probe is in the correct attenuation setting.
  6. Measure. Record the period, frequency, high time and low time, and compute the duty cycle. Use the DSO’s cursors or automatic measurements, and note which one you used.
  7. Compare. Put designed, calculated-with-real-parts and measured values side by side, and explain the differences (component tolerance, probe loading, scope accuracy).

Deliverable

  1. Design sheet (photo or scan is fine) with the equations, the ratio you derived, the chosen component values, and the recomputed frequency and duty cycle for the real parts.
  2. Circuit schematic with all component values labeled.
  3. Breadboard photo of the working circuit with the probe connected.
  4. DSO screenshot or photo showing at least 2 periods of the output, with the measured frequency, high time and duty cycle visible.
  5. Comparison table: designed vs. calculated (real parts) vs. measured, for frequency and duty cycle.
  6. Short answer (3 to 4 sentences): why can a basic 555 astable (two resistors and one capacitor) never give a duty cycle below 50%, and why is 60% reachable without any extra parts?

Resources

Reading

  1. 555 Timer Math: derives the astable frequency and duty cycle, and the formulas for choosing R₁ and R₂ from a target frequency, duty cycle and C. The equations themselves are in images on the page.
  2. Astable Multivibrator using IC 555 (IIT Kharagpur virtual lab): lab-style pre-test on the same experiment.
  3. NE555 datasheet (Texas Instruments): pinout, supply range and the standard astable circuit.

Videos (YouTube)

  1. Astable 555 timer: An amazing video by Ben Eater.
  2. 555 Timer as Astable Multivibrator (Working, Design and Derivations): A second explanation of the same circuit.
  3. Measuring Frequency, Duty Cycle, & Pulse Width: How to read these off a scope.

Tools

A DSO with a 10x probe. Check the attenuation setting and compensate the probe on the scope’s calibration output before measuring.

Optional: simulate the circuit first in Tinkercad Circuits to check your component values before building.


Task 12: Prime Number Detector with a K-Map

Objective

Learn Karnaugh maps from scratch by using one to design a real circuit. By the end you should be able to:

  • Fill a K-map from a truth table.
  • Circle valid groups (sizes 1, 2, 4, 8) and read an equation off them.
  • Explain why grouping works: two cells that touch differ in exactly one input, so that input drops out.
  • Build the result in logic gates and check it against every input combination.

The Task

Design and build a circuit with four inputs D C B A (a 4-bit number from 0 to 15, A is the least significant bit). The output LED turns on when the number is prime. Treat 0 and 1 as not prime.

Do this in Tinkercad Circuits using four slide switches as inputs, one LED as output, and plain gates (AND, OR, NOT) in between. No decoder or other “smart” ICs.

Steps

  1. Read first. Go through the K-map resources below until you can answer: what does it mean for two cells to “touch”, and what are the legal group sizes?
  2. Truth table. Write all 16 rows and mark the output for each.
  3. Raw circuit. Write one AND term for every row where the output is 1, OR them together, and build it in Tinkercad. Count the gates. This is your baseline.
  4. K-map. Fill in the blank map below from your truth table (cell numbers are the decimal value of D C B A).
  5. Group. Circle groups of 1s. Use the largest groups you can, let groups overlap, and remember that the edges of the map wrap around (left touches right, top touches bottom).
  6. Equation. Write one product term per group and OR them.
  7. Simplified circuit. Build it in Tinkercad and count the gates.
  8. Verify. Run through all 16 switch combinations and confirm both circuits match your truth table. Write down your predicted output for 3 inputs before testing them.

Blank K-map (rows D C, columns B A)

+----------+----+----+----+----+
| D C \ BA | 00 | 01 | 11 | 10 |
+----------+----+----+----+----+
|    00    |  0 |  1 |  3 |  2 |
|    01    |  4 |  5 |  7 |  6 |
|    11    | 12 | 13 | 15 | 14 |
|    10    |  8 |  9 | 11 | 10 |
+----------+----+----+----+----+
D C \ B A00011110
000132
014576
1112131514
10891110

Axis order is 00, 01, 11, 10 on purpose, so that neighbouring cells always differ in only one input. Use it as given.

Deliverable

  1. Tinkercad share link (viewable by anyone with the link) containing both the raw and the simplified circuit, labeled.
  2. One sheet (photo or scan is fine) with the truth table, the filled K-map with groups circled, and your final equation.
  3. Prediction table: 3 inputs, your predicted output, and the actual output.
  4. Gate counts: raw circuit vs. simplified circuit.
  5. Short answer (3 to 4 sentences): why can two touching cells be merged into one term?

Resources

  1. Karnaugh map playlist: the main K-map course. Cover the introduction and the 4-variable videos (grouping and wrap-around) before starting the task.
  2. Karnaugh Maps with 4 Variables: a second explanation of the same material, useful if the playlist doesn’t click.
  3. Logic Gates in Tinkercad: placing gates, switches and LEDs and running the simulation.
  4. Digital Electronics: Logic Gates Circuits on TinkerCad (playlist): more Tinkercad gate builds if you get stuck wiring.

Practice

Karnaugh Mapping worksheet (All About Circuits): a few questions to try before you start the task.

Tools

Tinkercad Circuits


TASK 13: Active Participation

Take part in any technical event, inter or intra college and submit the issued certificate of participation.

Enroll for a MOOC and complete the course.


TASK 14: Datasheets report writing

Topics: 1) MQ135 Gas sensor 2) L293D motor driver

Task Description: Study the datasheet of any one of the above and write a report on it. Specify about the ICs used in L293D, PWM, H-bridge etc. In case of MQ 135, specify the calibrations for different gases and the Freundlich Absorption Theorem Graph.


TASK 15: Sad servers - "Like LeetCode for Linux"

Sadservers is an excellent ground to test your Linux troubleshooting skills. Here is a troubleshooting scenario: Command Line Murders. Troubleshoot and Make Sad Servers Happy!


Level 2


CL - Cloud Computing

Task 1: Working with Git and GitHub Basics

Task Description
Start by understanding version control. Practice cloning repositories, making changes, committing those changes, and pushing them back to GitHub. Create branches and open pull requests to simulate collaborative workflows. Learn to review and merge pull requests to complete the development cycle.

Expected Task Outcomes
• Understand the fundamentals of version control and distributed repositories
• Learn how to solve merge conflict - git rebase
• Create and manage branches for feature development
• Contribute to atleast one open source project
• Implement and learn about git revert, git cherry-pick
• Create a customized Git workflow - Git config

Resource Links
• Git Official Documentation: https://git-scm.com/doc
• GitHub Learning Lab: https://github.com/apps/github-learning-lab
• Pro Git Book (free): https://git-scm.com/book/en/v2

Task 2: Exploring Docker Fundamentals

Task Description
Begin with learning the difference between containers and virtual machines. Practice using Docker CLI commands to pull images from Docker Hub, run containers, inspect running processes, view logs, and manage container lifecycles such as stopping and removing containers.

Expected Task Outcomes
• Articulate the key differences between containers and virtual machines
• Pull images from Docker Hub and run containers using CLI commands
• Inspect running processes, view container logs, and understand container state
• Manage full container lifecycles: start, stop, restart, and remove

Resource Links
• Docker Official Documentation: https://docs.docker.com/
• Docker Hub: https://hub.docker.com/
• Play with Docker (browser-based lab): https://labs.play-with-docker.com/

Task 3: Dockerize a Simple Application

Task Description
Learn Dockerfile basics and how to containerize applications. Write a Dockerfile for a simple static website or API provided as starter code. Build your Docker image from this Dockerfile and run the application container locally. Verify successful deployment by accessing the app from your browser.

Expected Task Outcomes
• Write a functional Dockerfile to containerize a provided application
• Build a Docker image and run it as a container on your local machine
• Map container ports to the host machine to access the app in a browser
• Understand image layers and how each Dockerfile instruction creates a layer

Resource Links
• Dockerfile Reference: https://docs.docker.com/engine/reference/builder/
• Best Practices for Writing Dockerfiles: https://docs.docker.com/develop/develop-images/dockerfile_best-practices/

Task 4: Launch and Manage an AWS EC2 Instance

Task Description
Explore AWS EC2 service and different instance types. Launch a free-tier EC2 instance, configure the security group to allow SSH access, and connect securely using SSH. Install a lightweight web server such as Nginx or Apache on the instance and ensure it is accessible via the public IP. Also, understand how CPU and memory work in a VM.

Expected Task Outcomes
• Launch an EC2 instance using the AWS Free Tier and configure its security group
• Connect to the instance securely over SSH using a .pem key pair
• Install and start a web server (Nginx or Apache) and confirm access via public IP
• Understand EC2 instance types, CPU credits, and memory allocation in cloud VMs

Resource Links
• AWS EC2 Getting Started Guide: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html
• AWS Free Tier Details: https://aws.amazon.com/free/
• Nginx Beginner's Guide: https://nginx.org/en/docs/beginners_guide.html

Task 5: Kubernetes Basics and Writing Pod Specs

Task Description
Understand key Kubernetes concepts and the structure of YAML manifest files. Write a simple Pod specification YAML to run a basic container (e.g., Nginx). Apply the manifest to your Minikube cluster and verify the Pod is running. Explore commands to get Pod status and logs.

Expected Task Outcomes
• Explain core Kubernetes concepts: Nodes, Pods, Clusters, and the Control Plane
• Write a valid Pod manifest YAML file to deploy a container image
• Apply manifests to a local Minikube cluster using kubectl
• Use kubectl commands to inspect Pod status, describe Pods, and view logs

Resource Links
• Kubernetes Official Documentation: https://kubernetes.io/docs/home/
• Minikube Getting Started: https://minikube.sigs.k8s.io/docs/start/
• Kubernetes YAML Basics: https://kubernetes.io/docs/concepts/workloads/pods/

Task 6: Manage AWS S3 and IAM with CLI

Task Description
Study AWS IAM concepts like users, roles, and policies, and learn to configure the AWS CLI. Create an IAM user with permissions to access S3, then create an S3 bucket from the CLI. Practice uploading, listing, and downloading files to/from the bucket using AWS CLI commands, reinforcing cloud storage handling.

Expected Task Outcomes
• Understand IAM concepts: users, groups, roles, and least-privilege policies
• Configure the AWS CLI with credentials and verify connectivity to AWS services
• Create an S3 bucket and manage objects via CLI (upload, list, download, delete)
• Apply IAM policies to restrict S3 access to specific users or roles

Resource Links
• AWS IAM Documentation: https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html
• AWS CLI S3 Command Reference: https://docs.aws.amazon.com/cli/latest/reference/s3/
• AWS S3 Getting Started: https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html

Task 7: Deploy a Containerized Application on Kubernetes

Task Description
Learn to write YAML manifests for Kubernetes deployments and services. Package your Dockerized app and deploy it using YAML files. Expose the app within the cluster via ClusterIP and externally using NodePort. Validate by accessing the app through the configured NodePort on your local machine.

Expected Task Outcomes
• Write Deployment YAML to deploy multiple replicas of a containerized application
• Expose the deployment within the cluster using a ClusterIP Service
• Expose the deployment externally using a NodePort Service and access it in a browser
• Scale deployments up and down using kubectl and observe rolling updates

Resource Links
• Kubernetes Deployments: https://kubernetes.io/docs/concepts/workloads/controllers/deployment/
• Kubernetes Services: https://kubernetes.io/docs/concepts/services-networking/service/

Task 8: Use Kubernetes Secrets and Environment Variables

Task Description
Understand how to handle sensitive data and configuration within Kubernetes using Secrets and ConfigMaps. Create a ConfigMap and mount it onto a deployment and let the underlying application use the configuration. Create a Kubernetes Secret with AWS credentials, update deployment YAML to use these Secrets as environment variables, and deploy the updated app. Verify that the app uses the credentials securely to interact with AWS S3.

Expected Task Outcomes
• Create and apply ConfigMaps to inject non-sensitive configuration into Pods
• Create Kubernetes Secrets to store AWS credentials without hardcoding them
• Mount Secrets as environment variables in a Deployment and verify their consumption
• Understand the difference between Secrets and ConfigMaps and when to use each

Resource Links
• Kubernetes Secrets: https://kubernetes.io/docs/concepts/configuration/secret/
• Kubernetes ConfigMaps: https://kubernetes.io/docs/concepts/configuration/configmap/

Task 9: Deploy an App to Push Files from Kubernetes to S3

Task Description
Build and deploy an application on Kubernetes capable of pushing files from a locally hosted app server to AWS S3. Use Kubernetes Secrets for storing AWS credentials securely. Validate the file upload process from the app interface to the S3 bucket and verify files in the cloud storage.

Expected Task Outcomes
• Build and containerize a file-upload application using a language/framework of your choice
• Deploy the app on Minikube with AWS credentials injected via Kubernetes Secrets
• Successfully upload a file from the app UI/CLI and verify it appears in the S3 bucket
• Integrate all Level 1 concepts: Docker, Kubernetes, IAM, S3, and Secrets into one working pipeline

Resource Links
• AWS SDK for Python (boto3): https://boto3.amazonaws.com/v1/documentation/api/latest/index.html
• AWS SDK for Node.js: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/
• Kubernetes Secrets in Pods: https://kubernetes.io/docs/tasks/inject-data-application/distribute-credentials-secure/


CY - Cybersecurity

Welcome to the Marvel Cybersecurity Module.
Level 1 of this module is designed to build a strong foundation by covering the essentials of computer networking, protocols, Windows, Linux, and core cybersecurity principles. These fundamentals are crucial— cybersecurity is not just about tools, but about understanding how systems work.
At its core, cybersecurity follows simple logic:
You can’t protect what you can’t see (or don’t understand), and you can’t break what you don’t know.
That’s why mastering these basics is the first step toward becoming skilled in both defending and attacking systems.

Once you complete Level 1, we’ll move into the more exciting part—hands-on hacking and defense techniques. Stay tuned!

Getting Started
To begin, you’ll need access to a platform called TryHackMe, where all course materials are hosted. Please follow the steps below to create your account:
Step 1: Go to https://tryhackme.com/
Step 2: Click on “Join for FREE” (top-right corner)

Step 3: Sign up using your Google, LinkedIn, or email account
Step 4: Complete any required details (password, captcha, etc.)
Step 5: Finish the introductory tour on the platform
Step 6: Access the Level 1 module using the link below: https://tryhackme.com/jr/uvce_marvel_level1


Level 3


CL - Cloud Computing

Task 1: Linux Fundamentals and Shell Scripting

Task Description
Build a practical understanding of Linux fundamentals, including file permissions, process management, disk usage, and environment variables. Write Bash scripts to inspect system usage and running processes, then schedule a script with cron and verify that its output is logged correctly.

Expected Task Outcomes
• Understand Linux file permissions, process management, and environment variables
• Write a Bash script that checks disk usage for each directory under /home and prints a warning if any directory exceeds 80% usage
• Write a Bash script that accepts a process name, checks whether it is running, and reports its PID and memory usage
• Display a friendly error message when the requested process is not running
• Schedule the process-checking script to run every five minutes using cron
• Configure and verify logging so that scheduled script output is recorded correctly

Resource Links
• GNU Bash Reference Manual: https://www.gnu.org/software/bash/manual/
• Linux man-pages project: https://man7.org/linux/man-pages/
• cron and crontab reference: https://man7.org/linux/man-pages/man5/crontab.5.html
• ShellCheck (Bash script analysis): https://www.shellcheck.net/

Task 2: Networking Fundamentals and SSH

Task Description
Understand how data travels across networks and how to inspect network connectivity, DNS resolution, HTTP traffic, and open ports. Use command-line networking tools to investigate two websites, interpret their output in plain English, examine services running on an EC2 instance, and configure SSH key-based authentication between two EC2 instances.

Expected Task Outcomes
• Run traceroute against two websites and explain what each hop represents
• Identify which traceroute hops appear to belong to AWS and which are outside AWS, documenting any uncertainty where ownership cannot be established
• Use nslookup and dig to resolve a domain and explain the important lines in their output
• Run netstat -tulnp on an EC2 instance, identify the service associated with each listening port, and assess whether that port should be publicly accessible
• Use curl -v to make an HTTP request and annotate the request headers, response headers, status code, and response body
• Generate an SSH key pair using ssh-keygen, copy the public key to a second EC2 instance using ssh-copy-id, and verify passwordless login

Resource Links
• Linux traceroute manual: https://man7.org/linux/man-pages/man8/traceroute.8.html
• dig manual: https://bind9.readthedocs.io/en/latest/manpages.html
• nslookup documentation: https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/nslookup
• curl command-line tool documentation: https://curl.se/docs/
• OpenSSH manual pages: https://www.openssh.com/manual.html
• Amazon EC2 security groups: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html

Task 3: Deploy a Public-Facing App on AWS EC2

Task Description
Take a Dockerized application from Level 1 and deploy it on an AWS EC2 instance so that it can be accessed over the internet using a public IP address. Install Docker on a fresh instance, run the application container on port 80, configure inbound HTTP access, and practise manually updating the deployed application after publishing a new image to Docker Hub.

Expected Task Outcomes
• Connect to a fresh EC2 instance over SSH and install Docker
• Pull the application's Docker image from Docker Hub
• Run the container with the application available on port 80
• Configure the EC2 security group to allow inbound HTTP traffic on port 80
• Access the application through a browser using the EC2 public IP address and verify that it is live
• Make a small change to the application locally, build and push an updated image to Docker Hub, then pull and redeploy the image on EC2 manually

Resource Links
• Amazon EC2 Getting Started Guide: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html
• Docker Engine installation: https://docs.docker.com/engine/install/
• Docker image build documentation: https://docs.docker.com/build/
• Docker Hub documentation: https://docs.docker.com/docker-hub/
• EC2 security groups: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html

Task 4: Introduction to Databases

Task Description
Learn what a relational database is and why applications use persistent storage instead of keeping all data in memory. Practise basic SQL operations, run a MySQL container as a Kubernetes Pod, connect to it with kubectl exec, and observe what happens to data when the Pod is restarted without persistent storage.

Expected Task Outcomes
• Explain relational databases and the meaning of tables, rows, and columns
• Describe why applications cannot rely on in-memory storage for data that must survive process or system restarts
• Create a database table and practise SQL INSERT, SELECT, UPDATE, and DELETE operations
• Write a Kubernetes Pod manifest that runs a MySQL container and passes database credentials through environment variables
• Connect to the running Pod using kubectl exec and execute SQL queries inside the container
• Restart the Pod and observe that data stored only in the container's ephemeral filesystem is lost; explain the role of persistent storage

Resource Links
• MySQL Reference Manual: https://dev.mysql.com/doc/refman/8.4/en/
• SQL statements in MySQL: https://dev.mysql.com/doc/refman/8.4/en/sql-statements.html
• Kubernetes Pods: https://kubernetes.io/docs/concepts/workloads/pods/
• Run a command in a container: https://kubernetes.io/docs/tasks/debug/debug-application/get-shell-running-container/
• Kubernetes volumes: https://kubernetes.io/docs/concepts/storage/volumes/

Task 5: CI/CD Pipeline with GitHub Actions

Task Description
Automate the manual application redeployment process from Task 3 by creating a CI/CD workflow with GitHub Actions. Start from the provided YAML template, understand its triggers, jobs, steps, and secrets, then configure it to build and publish a Docker image whenever changes are pushed to main. Add an SSH-based deployment step that updates the application running on EC2.

Expected Task Outcomes
• Explain what Continuous Integration (CI) and Continuous Delivery/Deployment (CD) mean and why they are useful
• Set up a GitHub Actions workflow using the provided YAML template
• Understand the workflow's triggers, jobs, steps, and secrets
• Configure the workflow to build a Docker image and push it to Docker Hub on every push to main
• Store required credentials and connection details in GitHub Actions secrets rather than hardcoding them in the workflow
• Add a deployment step that connects to EC2 over SSH, pulls the updated image, and restarts the container
• Push a code change, observe the workflow run end to end, and verify that the update is live without manually operating the server

Resource Links
• GitHub Actions documentation: https://docs.github.com/en/actions
• Understanding GitHub Actions: https://docs.github.com/en/actions/about-github-actions/understanding-github-actions
• Using secrets in GitHub Actions: https://docs.github.com/en/actions/security-for-github-actions/security-guides/using-secrets-in-github-actions
• Docker build and push action: https://github.com/docker/build-push-action
• Docker Hub documentation: https://docs.docker.com/docker-hub/

Task 6: Kubernetes Services

Task Description
Understand how Kubernetes Services provide network access to applications running inside a cluster. Deploy an application on Minikube and expose it using ClusterIP, NodePort, and LoadBalancer. Test how each service type can be reached and compare the use cases and networking behaviour of the three types.

Expected Task Outcomes
• Deploy an application on Minikube and expose it using a ClusterIP Service
• Verify that the ClusterIP application is reachable from within the cluster by sending a request from another Pod using kubectl exec
• Change the Service type to NodePort and access the application from a browser
• Use minikube tunnel to test a LoadBalancer Service and access it through the address made available by Minikube
• Explain the networking differences between ClusterIP, NodePort, and LoadBalancer
• Write a short comparison describing what each Service type does and when it would be appropriate to use it

Resource Links
• Kubernetes Services: https://kubernetes.io/docs/concepts/services-networking/service/
• Minikube service access: https://minikube.sigs.k8s.io/docs/handbook/accessing/
• Minikube tunnel: https://minikube.sigs.k8s.io/docs/commands/tunnel/
• kubectl reference: https://kubernetes.io/docs/reference/kubectl/

Task 7: Introduction to AWS EKS

Task Description
Move from a local Kubernetes environment such as Minikube to a managed Kubernetes cluster on AWS. Learn the purpose of Amazon Elastic Kubernetes Service (EKS), create a cluster after reviewing the prerequisites and costs, configure access from your local machine, and deploy a simple Pod using kubectl.

Expected Task Outcomes
• Explain the role of Amazon EKS and how a managed cloud Kubernetes cluster differs from a local Minikube cluster
• Review the prerequisites and potential costs before creating an EKS cluster
• Create an AWS EKS cluster using an appropriate documented method
• Configure local access to the cluster and verify connectivity with kubectl
• Deploy a simple Pod to the EKS cluster using kubectl commands and verify its status

Resource Links
• Amazon EKS User Guide: https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html
• Getting started with Amazon EKS: https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html
• Connecting kubectl to an EKS cluster: https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html
• Kubernetes kubectl overview: https://kubernetes.io/docs/reference/kubectl/

Task 8: Introduction to Observability

Task Description
Build the habit of inspecting an application's behaviour while it is running. Learn how CPU, memory, and disk resources relate to a Kubernetes Pod and what can happen when resource limits or available capacity are exceeded. Deploy a Pod, stream its logs while sending requests, inspect Pod- and node-level resource usage, and access a metrics endpoint through port forwarding.

Expected Task Outcomes
• Explain how CPU, memory, and disk resources relate to a Kubernetes Pod
• Describe what can happen when a Pod exceeds its memory or CPU limits, or when storage runs out
• Deploy a Pod and stream its logs using kubectl logs -f while sending requests to the application
• Use Kubernetes commands to inspect Pod details and understand Pod- and node-level resource usage
• Use kubectl port-forward to expose a Pod's metrics endpoint locally and open the endpoint in a browser
• Explain what the observed logs and resource metrics reveal about the application's runtime behaviour

Resource Links
• Kubernetes resource management for Pods and containers: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
• Kubernetes logging: https://kubernetes.io/docs/concepts/cluster-administration/logging/
• kubectl logs reference: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_logs/
• kubectl top reference: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_top/
• kubectl port-forward reference: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_port-forward/


CY - Cybersecurity

Red Team Path

The Red Team Path introduces offensive security concepts through structured, hands-on learning. Work through the rooms in order to build an understanding of the cyber kill chain, penetration-testing methodology, reconnaissance, network scanning, common web vulnerabilities, red-team engagements, and phishing awareness.

Complete all activities only within TryHackMe labs or other environments for which you have explicit authorisation. Keep notes on the commands used, the observations made, and the lessons learned.

Task 1: Cyber Kill Chain

Task Description
Explore the Cyber Kill Chain framework and understand the stages commonly used to describe an adversary's activity, from reconnaissance through actions on objectives. Learn how defenders can use the framework to recognise attacker behaviour and identify opportunities to disrupt an attack.

Expected Task Outcomes
• Explain the purpose of the Cyber Kill Chain framework
• Identify and describe its major phases: reconnaissance, weaponization, delivery, exploitation, installation, command and control, and actions on objectives
• Understand how open-source intelligence (OSINT) supports reconnaissance
• Explain how defenders can identify opportunities to detect, prevent, or disrupt activity at different stages of the kill chain
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Cyber Kill Chain: https://tryhackme.com/room/cyberkillchainzmt

Task 2: Penetration Testing Fundamentals

Task Description
Learn the purpose, scope, and workflow of a penetration test. Understand how penetration testing differs from other security assessments, why authorisation and scope are essential, and how findings should be documented and communicated.

Expected Task Outcomes
• Explain the purpose of a penetration test and how it differs from a vulnerability assessment
• Identify the typical stages of a penetration-testing engagement
• Understand the importance of scope, rules of engagement, authorisation, and responsible conduct
• Recognise the role of evidence, impact assessment, and clear reporting in communicating findings
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Pentesting Fundamentals: https://tryhackme.com/room/pentestingfundamentals

Task 3: Passive Reconnaissance

Task Description
Practise collecting information about a target from publicly available sources without directly interacting with the target's systems. Explore domain-registration information, DNS records, certificate transparency, subdomain discovery, and internet-exposed service search engines.

Expected Task Outcomes
• Explain the difference between passive and active reconnaissance
• Use whois, dig, and nslookup to gather and interpret domain information
• Explore how certificate transparency logs and public sources can reveal subdomains
• Understand how services such as Shodan can provide information about internet-exposed systems
• Record findings clearly and distinguish verified facts from assumptions
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Passive Reconnaissance: https://tryhackme.com/room/passiverecon

Task 4: Active Reconnaissance

Task Description
Learn how direct interaction with a system can reveal information about its availability, network path, exposed services, and web technologies. Practise the room's reconnaissance techniques in the provided lab environment and understand that active probing may be logged or detected.

Expected Task Outcomes
• Explain how active reconnaissance differs from passive reconnaissance and why it may be detectable
• Use browser Developer Tools to inspect relevant web-page information, headers, scripts, and certificates
• Use ping to test reachability and understand the limitations of interpreting TTL values
• Use traceroute or equivalent tools to examine network paths
• Use telnet or netcat in the lab to inspect service responses and banners
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Active Reconnaissance: https://tryhackme.com/room/activerecon

Task 5: Nmap Basic Port Scans

Task Description
Learn how Nmap discovers hosts and scans ports. Practise basic scan techniques in the authorised TryHackMe lab, then interpret the results to understand which ports are open, closed, or filtered and what those states suggest about a target's network services.

Expected Task Outcomes
• Explain the purpose of Nmap in network discovery and port scanning
• Perform the basic scans demonstrated in the room against the assigned lab target
• Interpret common port states, including open, closed, and filtered
• Understand at a high level how TCP connection scans and SYN scans differ
• Record scan results and explain what they reveal about the lab target
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Nmap 01: https://tryhackme.com/room/nmap01
• Nmap Reference Guide: https://nmap.org/book/man.html

Task 6: Nmap Advanced Port Scans

Task Description
Build on basic scanning knowledge by exploring the more advanced Nmap scan techniques covered in the room. Learn how scan behaviour and packet flags affect the results, and practise interpreting the output in the provided lab environment.

Expected Task Outcomes
• Explain the purpose of the advanced Nmap scan techniques covered in the room
• Run the relevant scans against the assigned TryHackMe lab target
• Compare the results of different scan types and explain why they may differ
• Understand that network filtering, host configuration, and firewall behaviour can affect scan results
• Document the commands used and the conclusions supported by the results
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Nmap 02: https://tryhackme.com/room/nmap02
• Nmap Reference Guide: https://nmap.org/book/man.html

Task 7: OWASP Top 10 2025 — Part 1

Task Description
Begin exploring the web application security risks covered in the OWASP Top 10 2025 learning rooms. Understand the vulnerability categories and scenarios presented in the room, and learn to recognise how weaknesses in web applications can affect confidentiality, integrity, and availability.

Expected Task Outcomes
• Review the OWASP Top 10 2025 topics introduced in the room
• Explain the vulnerability categories and examples covered by the exercises
• Identify the underlying causes and potential impact of the demonstrated weaknesses
• Complete the room's practical exercises only in the provided lab environment
• Record key observations and defensive measures relevant to the topics studied

Resource Links
• TryHackMe — OWASP Top 10 2025: Part 1: https://tryhackme.com/room/owasptopten2025one
• OWASP Top 10: https://owasp.org/www-project-top-ten/

Task 8: OWASP Top 10 2025 — Part 2

Task Description
Continue studying the web application security topics covered by the second OWASP Top 10 2025 room. Work through the provided examples to understand how the relevant weaknesses arise, how their impact can be assessed, and what secure development practices help prevent them.

Expected Task Outcomes
• Review the OWASP Top 10 2025 topics introduced in this room
• Explain the causes and potential consequences of the vulnerabilities demonstrated
• Complete the practical exercises in the assigned TryHackMe environment
• Identify relevant prevention, validation, access-control, or configuration practices where applicable to the topics covered
• Summarise the main lessons from the room in your own words

Resource Links
• TryHackMe — OWASP Top 10 2025: Part 2: https://tryhackme.com/room/owasptopten2025two
• OWASP Top 10: https://owasp.org/www-project-top-ten/

Task 9: OWASP Top 10 2025 — Part 3

Task Description
Complete the OWASP Top 10 2025 room sequence by exploring the remaining topics and practical scenarios presented in Part 3. Focus on understanding the security weaknesses, the conditions that make them possible, and the lessons developers and security testers can take from each exercise.

Expected Task Outcomes
• Review the OWASP Top 10 2025 topics introduced in this room
• Explain the relevant weaknesses, their likely impact, and the lessons demonstrated by the exercises
• Complete the assigned practical activities in the TryHackMe lab
• Identify defensive practices that address the issues covered in the room
• Write a short summary of the key concepts learned across Parts 1, 2, and 3

Resource Links
• TryHackMe — OWASP Top 10 2025: Part 3: https://tryhackme.com/room/owasptopten2025three
• OWASP Top 10: https://owasp.org/www-project-top-ten/

Task 10: Red Team Fundamentals

Task Description
Understand the purpose and structure of a red-team engagement and how it differs from a conventional vulnerability assessment or penetration test. Explore engagement roles, objectives, adversary emulation, and the use of frameworks such as the Cyber Kill Chain to describe attacker behaviour.

Expected Task Outcomes
• Explain what a red-team engagement is and what it aims to evaluate
• Distinguish red teaming from vulnerability assessments and penetration testing
• Identify the roles, stakeholders, objectives, and planning considerations involved in an engagement
• Explain adversary emulation and the use of tactics, techniques, and procedures (TTPs)
• Describe how a kill-chain framework can help organise and assess an engagement
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Red Team Fundamentals: https://tryhackme.com/room/redteamfundamentals
• MITRE ATT&CK: https://attack.mitre.org/

Task 11: Phishing Emails — Part 1

Task Description
Learn how to inspect suspicious emails and recognise common phishing indicators. Examine the evidence presented in the TryHackMe exercises, including sender details, links, attachments, and message content, to understand how phishing attempts can be identified and reported.

Expected Task Outcomes
• Explain what phishing is and why it is used in social-engineering attacks
• Inspect email sender details, message content, links, and attachments for suspicious indicators
• Recognise common warning signs such as spoofed senders, misleading links, unexpected attachments, and urgent requests
• Understand safe handling and reporting practices for suspicious emails
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Phishing Emails 1: https://tryhackme.com/room/phishingemails1tryoe
• CISA — Recognize and Report Phishing: https://www.cisa.gov/secure-our-world/recognize-and-report-phishing

Blue Team Path

The Blue Team Path introduces defensive security operations, security monitoring, threat hunting, and endpoint security. Focus on understanding what defenders observe, how they investigate suspicious activity, and how security controls help detect and respond to threats.

Task 12: SOC Fundamentals

Task Description
Explore the role of a Security Operations Center (SOC) and how analysts monitor, investigate, and respond to security events. Learn about SOC responsibilities, common workflows, alert triage, and the tools used to support defensive operations.

Expected Task Outcomes
• Explain the purpose and core responsibilities of a SOC
• Understand common SOC roles and the general alert-investigation workflow
• Distinguish security events, alerts, and incidents at a basic level
• Explain why context, prioritisation, documentation, and escalation matter during investigations
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — SOC Fundamentals: https://tryhackme.com/room/socfundamentals

Task 13: Introduction to SIEM

Task Description
Learn how Security Information and Event Management (SIEM) systems collect and analyse security logs from different sources. Explore how logs are used to search for activity, identify suspicious patterns, and support security investigations.

Expected Task Outcomes
• Explain the purpose of a SIEM and the types of data it can collect
• Understand how logs from different systems provide context during an investigation
• Practise the searches, filters, and analysis activities demonstrated in the room
• Explain how SIEM alerts can help analysts identify and investigate suspicious activity
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Introduction to SIEM: https://tryhackme.com/room/introtosiem

Task 14: Threat Hunting Introduction

Task Description
Understand threat hunting as a proactive approach to searching for signs of malicious activity that may not have been detected by existing alerts. Explore the hunting mindset, the use of hypotheses, and the analysis of available security data to investigate suspicious behaviour.

Expected Task Outcomes
• Explain what threat hunting is and how it differs from alert-driven investigation
• Understand how a hypothesis can guide a threat-hunting investigation
• Identify the role of logs, telemetry, and contextual evidence in hunting
• Practise the investigation steps and analysis activities presented in the room
• Document findings and explain how evidence supports or weakens a hypothesis

Resource Links
• TryHackMe — Threat Hunting Introduction: https://tryhackme.com/room/threathuntingintroduction

Task 15: Introduction to Endpoint Security

Task Description
Learn how endpoint security helps protect devices such as workstations and servers. Explore the security controls and monitoring concepts introduced in the room, and understand how endpoint telemetry can help defenders detect suspicious activity and investigate potential compromise.

Expected Task Outcomes
• Explain what an endpoint is and why endpoint security is important
• Understand the purpose of endpoint protection and monitoring controls covered in the room
• Recognise how endpoint activity can provide evidence during security investigations
• Complete the practical activities and questions in the TryHackMe room
• Summarise the defensive concepts learned and how they support detection and response

Resource Links
• TryHackMe — Introduction to Endpoint Security: https://tryhackme.com/room/introtoendpointsecurity

Practical

The practical section brings the learning paths together through hands-on web application security exercises. Work only within the intentionally vulnerable training application and the lab environment provided for this course. Document the issue investigated, the evidence observed, the impact, and the relevant mitigation.

Task 16: OWASP Juice Shop

Task Description
Explore OWASP Juice Shop, an intentionally vulnerable web application designed for security training. Investigate the application in the authorised lab environment, work through suitable challenges, and connect the vulnerabilities you observe to the web security concepts covered in the Red Team Path.

Expected Task Outcomes
• Navigate the Juice Shop application and understand its purpose as a security training environment
• Complete a selection of challenges appropriate to the course's learning objectives
• Identify the vulnerability or security weakness demonstrated by each completed challenge
• Document the steps taken, the evidence observed, and the potential impact
• Where applicable, explain the defensive measures that would help prevent or mitigate the issue
• Relate practical findings to the OWASP Top 10 topics studied earlier

Resource Links
• TryHackMe — OWASP Juice Shop: https://tryhackme.com/room/owaspjuiceshop
• OWASP Juice Shop Project: https://owasp.org/www-project-juice-shop/

Task 17: MARVEL Cybersecurity Red Team Lab

Task Description
Complete the practical exercise provided by the MARVEL Cybersecurity Red Team Lab. Use the techniques and concepts learned throughout the course to investigate the assigned lab environment, follow the exercise objectives, and document your approach and findings.

Expected Task Outcomes
• Access and review the MARVEL Red Team Lab instructions
• Identify the objective and scope of the assigned exercise before beginning
• Apply relevant reconnaissance, scanning, and web-security concepts within the authorised lab
• Record the tools used, steps taken, evidence collected, and conclusions reached
• Summarise the security weaknesses or lessons demonstrated by the exercise and, where relevant, suggest mitigations

Resource Links
• MARVEL Cybersecurity Red Team Lab: https://28d33.github.io/Marvel-CLCY_L2-CY_RED-Lab/


Level 4


Task 1 - Encryption

What are ciphers? Learn about caesar, Vigenere and substitution cipher, Why is this different from encryption techniques like SHA256? Learn about symmetric and asymmetric keys(Public and Private keys) (Optional : How is prime numbers used in RSA)

Task 2 - Hashing

Learn about Hashing ex:SHA256 algorithm ,Salting, Hash Tables (optional: Learn about MD5)

Task 3 - SSH

Write a script to SSH: Secure shell(SSH) is a network communication protocol that enables two computers to communicate . Write a script to SSH into a server and search the whole server for public keys/private keys and upload them to another server.

Task 4 - NMap

Learn how NMap works and Scan the ports, Host and OS and output these details in a file (optional: Analyze the results and report what you have found)

Task 5 - NMap Continued

Find out the use cases Wireshark and its working, Capture and Analyze Data Packs, Work with the various filters and statistics and report what you have found Reference: https://nmap.org/book/man.html https://www.wireshark.org/docs/

UVCE,
K. R Circle,
Bengaluru 01