Working with Command Line

This lab helped me get more comfortable using basic Linux commands in the terminal. I practiced navigating directories using both absolute and relative paths, listing file contents in different formats, and managing files and directories through commands like cp, mv, mkdir, and rm. One of the key concepts I learned was understanding how the directory structure works and how to move between folders efficiently without relying on a graphical interface.

A small challenge I faced was remembering when to use absolute versus relative paths, especially when switching between directories like /etc and /etc/skel. It took some trial and error to get used to how .. moves up one directory. Once I understood that, navigating became much easier.

Overall, this lab strengthened my confidence in working directly from the command line. I now have a better grasp of file management and directory navigation in Linux, which are essential skills for system administration and cybersecurity work.

Working with VI Editor

This lab focused on working with text files using the vi editor and applying various editing commands within the terminal. I learned how to open, navigate, and modify a file entirely from the command line, which is a key skill for managing system files in Linux. Commands like inserting text, searching for specific words, copying and pasting lines, and performing replacements helped me understand how powerful the vi editor can be once you get comfortable with it.

One challenge I faced was remembering the correct keys for switching between insert mode and command mode, especially when trying to save or quit the editor. At first, I made small mistakes that caused unwanted edits, but after repeating the steps a few times, I became more confident navigating and editing within vi.

Overall, this lab improved my command-line text editing skills and showed me how to efficiently modify system files without relying on a GUI. Learning to use vi effectively will be very helpful for future cybersecurity and Linux administration tasks

Group and User Management

This lab taught me how to manage user and group accounts in Linux using command-line tools. I practiced creating and modifying user accounts, setting passwords, changing shells, and managing group memberships. I also learned how to check user and group information with commands like grep, and how to set ownership and permissions for files. These are tasks that help keep a system organized and secure.

The main challenge I faced was remembering the right syntax for each command, especially when using options to create home directories or modify groups without removing existing memberships. Once I reviewed the commands and understood their functions, it became much easier to apply them correctly.

Overall, this lab helped me understand how Linux handles users, groups, and permissions. I now feel more confident in performing basic administrative tasks and maintaining proper account management for system security.

Password Cracking

This lab had me create multiple user accounts with passwords of varying complexity, export their password hashes, and use John the Ripper to attempt cracking them. It gave me practical experience with password security and showed how different types of passwords respond to attack. I was able to see firsthand how simple dictionary words or short numeric passwords can be cracked almost immediately, while more complex combinations with uppercase letters, numbers, and symbols are much harder to break.

I learned how Linux stores password hashes in /etc/shadow and why root access is required to access them. I also practiced exporting hashes and preparing them so that John the Ripper could process them in wordlist mode using rockyou.txt. Observing the cracking process helped me understand the relationship between password complexity and vulnerability, as well as the limitations of automated cracking in a short time frame.

One challenge I faced was remembering the correct commands for exporting and formatting the hashes, as well as ensuring proper permissions when handling sensitive files. I feel a bit more confident on this but could use more practice.

Overall, this lab reinforced the importance of creating strong passwords and showed how password auditing tools can help identify weak credentials. It also emphasized the need for ethical practices and caution when working with sensitive system data.

File Permissions

This lab focused on user and group management, file permissions, and the use of SGID to control shared directory access. I created multiple groups and user accounts, assigned primary and secondary groups, and practiced setting passwords and login shells. I also set up a shared project directory and applied permissions to ensure that only group members could access its contents. This lab reinforced the importance of proper group management and permissions in a collaborative Linux environment.

I learned how to use the umask command to control default file permissions for a user, and I practiced checking the resulting permissions after creating files. Copying files into the shared directory as different users helped me understand how ownership, group membership, and permissions interact to allow or restrict access. Applying SGID to the shared directory showed me how to make files inherit group ownership, which is essential for secure collaboration. Removing SGID and observing the changes highlighted how sensitive directory settings affect accessibility.

One challenge I faced was remembering the correct octal values for permissions and ensuring that the SGID was applied correctly to achieve the intended access control. Switching between different user accounts to test file access also required careful attention to avoid permission errors.

Overall, this lab improved my understanding of Linux user and group management, file permissions, and collaborative access controls. It demonstrated the practical importance of properly setting and testing permissions to maintain both security and usability in a multi-user environment.

Storage Management

This lab focused on working with local storage in Linux, starting with checking the system’s current disks and ending with creating and using a new one. I first used basic storage commands to see what hard drives and partitions were already attached to the virtual machine. Doing this gave me a clear baseline of the system before making any changes. After that, I added a new virtual hard disk to the VM and checked the system again to see how Linux recognized the new storage.

I learned how useful commands like ls, fdisk, and parted are for confirming what disks are available and how they are set up. Creating a new partition and formatting it with an ext4 filesystem helped me understand what actually happens behind the scenes before a disk can be used. Mounting the new partition to the /cyse directory made it feel more real, since I could interact with it just like any other folder. Creating a text file in that directory and then unmounting it helped reinforce how mounting and unmounting storage works in everyday use.

One challenge I ran into was double-checking that I was modifying the new virtual disk and not an existing one, since a mistake there could be serious. Keeping the steps in the right order also mattered, especially when switching between partitioning, formatting, and mounting.

Overall, this lab made local storage in Linux feel much less intimidating. It helped me better understand how disks are added, prepared, and connected to the file system, and why carefully checking your work is so important when managing storage.

Shell Script

This lab focused on the basics of shell scripting and how scripts can automate simple decision-making tasks in Linux. I created executable shell scripts using the vi editor, added the correct permissions, and ran them directly from the terminal. The lab walked through using conditional statements, user input, and file checks, which helped me better understand how scripts interact with users and the file system.

In Task A, I learned how to use a shebang, read user input, and apply an if statement to compare values. Writing a script that checks whether a number is greater than 10 showed me how conditions work in a real scenario and how scripts respond differently based on input. Seeing the output change depending on the number entered made the logic easier to understand.

In Task B, I worked with files and directories by checking whether an input already existed and determining if it was a directory or a regular file. I learned how to display file contents, create new files when they did not exist, and use redirection to write my name into a file. This task helped connect scripting with everyday file management tasks in Linux.

One challenge I faced was remembering the correct syntax for conditional checks and file tests, since small mistakes can prevent the script from running correctly. Making sure the script had execute permissions before running it was also something I had to double-check.

Overall, this lab made shell scripting feel more practical and less overwhelming. It showed how even simple scripts can save time and make system tasks more efficient, which is useful for both system administration and cybersecurity work.

Task Automation

This assignment focused on automating system backups using shell scripting and crontab scheduling. I started by creating a new user named Alice with a home directory, which set up a realistic scenario for backing up a specific user’s data. This helped show how administrative tasks and automation work together in a real Linux environment.

I learned how to write a shell script that creates a backup of Alice’s home directory using the tar command. The script takes user input for my MIDAS name and the current date, then uses those values to build a clear and organized filename. Creating the archive and moving it into the /var/backups directory helped reinforce best practices for where backups should be stored. I also applied compression to the backup file, which showed how compression can save disk space while keeping important data intact.

Using crontab was one of the most important parts of this assignment. Scheduling the backup script to run automatically every minute for a short time showed how backups can happen without manual effort. Checking the /var/backups directory and seeing multiple backup files being created made the automation aspect very clear. Cancelling the cron job afterward helped me understand how to safely stop scheduled tasks when they are no longer needed.

One challenge I faced was making sure the cron job used the correct paths and permissions, since cron does not always behave the same way as running a script in the terminal. Formatting the date and filename correctly also took some attention to avoid errors.

Overall, this assignment showed how powerful automation can be in Linux. It made clear why regular backups are important and how shell scripting with cron can ensure they happen consistently and efficiently without being forgotten.

Networking Basics

This assignment focused on subnetting and breaking down IP addresses into their network components. I worked through two different subnetting problems and calculated the network address, broadcast address, first usable IP, last usable IP, and maximum number of hosts for each network. Filling in both decimal and binary values helped connect the math behind subnetting to how IP addresses actually work.

I learned how the subnet mask directly controls the size of the network and the number of available hosts. Converting IP addresses and subnet masks into binary made it clearer how network and host bits are separated. From there, figuring out the network and broadcast addresses felt more logical instead of just guessing. Comparing Task A and Task B helped me see how changing the subnet size impacts the address range and host capacity.

One challenge was keeping track of binary conversions and making sure each value lined up correctly, especially when working near the subnet boundaries. It was easy to make small mistakes if I rushed, so I had to slow down and double-check my calculations. Remembering that the first and last IPs are reserved also took some attention.

Overall, this assignment helped solidify my understanding of subnetting. It made IP addressing feel more structured and less confusing, and it showed why subnetting is an important skill for networking and cybersecurity.