Professional Goals Upon Graduation

After finishing my degree, I want to step into cybersecurity and systems administration with a focus on remote work. My aim is to build and defend networks from wherever I am, using Linux and automation to keep systems reliable and secure. I’ve spent years working in Linux environments, so I want to put that experience to use in places where uptime and security are non‑negotiable.

Working remotely appeals to me because it fits the way I operate: independent, detail‑oriented, and able to manage my own time. I want to contribute to organizations by designing systems that are secure by default, scalable as they grow, and resilient when things go wrong. I’m especially interested in automating defensive measures so that security doesn’t depend on someone remembering to run a command at the right time.

Long term, I see myself as someone who not only keeps systems running but also communicates clearly with teams and leadership. I want to be trusted to explain technical risks in plain language and to make decisions that balance efficiency with ethics. My goal is to build a career where I can protect infrastructures and the people who rely on them, while working in a way that gives me flexibility and autonomy.

Overall Reflection on CYSE 270

CYSE 270 gave me a chance to slow down and put structure around skills I’ve had for years. I’ve always worked in Linux, but this course asked me to show each step carefully, document outputs, and connect the basics to bigger ideas in cybersecurity. That shift from “I know how to do this” to “I can explain and prove it” was valuable.

The labs moved in a clear progression: navigation, editing, user management, permissions, storage, scripting, backups, and networking. Taken together, they show how Linux is the backbone of secure systems. The course reminded me that security starts with fundamentals. If you can’t navigate confidently, manage accounts properly, or configure permissions correctly, you won’t be able to build or defend networks.

What stood out most was the emphasis on precision and documentation. In my own use, I move quickly through commands, but here I had to slow down and show the process. That discipline is exactly what’s needed in professional environments, especially when working remotely, where clear records and communication matter even more.

Overall, CYSE 270 strengthened my confidence not just in my technical ability but in my ability to present work in a way that others can rely on. It confirmed that cybersecurity and systems administration are the right path for me, and it gave me a solid foundation to keep building toward my professional goals.

Labs

Lab 1 – Ubuntu Basics

annotated-Prescott-Kowalski-Ubuntu-CYSE270

Experience:
This lab was more of a refresher than an introduction. I’ve used Linux for years, so running commands like echo, date, ls, and pwd felt familiar. What it did give me was a chance to confirm that I could apply those basics in a structured, academic setting and show consistency in my workflow.
Key Concepts / Skills Learned:

  • Reinforced the importance of precision in commands (ls, pwd, etc.).
  • Practiced documenting simple outputs in a way that aligns with course expectations.
  • Strengthened confidence in navigating the file system quickly and cleanly.

Challenges Faced:
There weren’t major technical hurdles, but the challenge was slowing down enough to present the basics clearly, rather than rushing through them as I might in everyday use.
Overall Takeaways:
Even for someone experienced with Linux, revisiting fundamentals is valuable. It reminded me that the smallest commands are the building blocks for more advanced tasks, and that accuracy and presentation matter just as much as speed.

Lab 2 – Basic Linux Navigation

annotated-CYSE-270_-Linux-System-for-Cybersecurity-Assignment-2-Prescott-Kowalski

Experience:
This lab focused on moving through the Linux file system and working with directories and files. Since I’ve used Linux for years, the commands themselves were familiar, but the exercise was useful for showing how to apply them step‑by‑step in an academic setting. It was less about learning something new and more about proving that I could document the basics clearly.
Key Concepts / Skills Learned:

  • Navigating with absolute and relative paths (cd /etc, cd skel, cd ..).
  • Listing files with ls and ls -l for detailed information.
  • Using wildcards to filter results (like listing files starting with “s”).
  • Checking file types with the file command.
  • Creating, renaming, copying, and deleting directories and files (mkdir, cp, mv, rm).

Challenges Faced:
The commands themselves weren’t difficult, but the challenge was slowing down enough to show each step cleanly. In everyday use I’d move quickly, but here I had to be deliberate and make sure the outputs matched what the lab required.
Overall Takeaways:
Even for someone experienced with Linux, revisiting the basics reinforces good habits. The lab highlighted how important it is to be precise and consistent, especially when documenting work. It also reminded me that small commands form the foundation for more advanced system administration tasks.

Lab 3 – VI Editor

https://drive.google.com/file/d/1OiLkZLAzq06wtb74fbSe2RJ1GibdL19K/view?usp=sharing

Experience:
This lab focused on practicing with the vi editor. I’ve used text editors before, but working through the commands step‑by‑step reinforced how vi operates differently with modes and shortcuts. The lab gave me a chance to show that I can edit files efficiently and document the process clearly.
Key Concepts / Skills Learned:

  • Switching between insert and command modes.
  • Navigating within a file (gg, G, w, 3) etc.).
  • Editing text with commands like yy (yank), p (paste), dw (delete word), and dd (delete line).
  • Searching and replacing text (/example, :%s/http/HTTP/g).
  • Saving and quitting with :wq.

Challenges Faced:
The main challenge was remembering the exact keystrokes for each action, since vi is less forgiving than modern editors. It required slowing down and being precise with commands.
Overall Takeaways:
This lab reinforced that vi is powerful once you get comfortable with its workflow. Even though I already knew the basics, practicing systematically helped me sharpen my speed and accuracy. It reminded me that knowing how to use vi is essential for working on systems where lightweight, terminal‑based editing is the only option.

Lab 4 – User & Group Management

annotated-Lab-4-Kowalski

Experience:
This lab focused on creating and managing user accounts and groups. Since I’ve worked with Linux for years, the commands were familiar, but the lab gave me a chance to demonstrate them in a structured way. It was about showing how to set up accounts, assign groups, and manage permissions in a clean, repeatable process.

Key Concepts / Skills Learned:

  • Creating users with home directories and setting login shells (useradd, passwd, usermod).
  • Managing groups (groupadd, groupmod, groupdel) and assigning users to primary and secondary groups.
  • Checking account and group information with grep, id, and groups.
  • Understanding how group ownership persists even after a group is deleted (stored as numeric GID).
  • Using sudo privileges and switching between accounts (su - username).

Challenges Faced:
The commands themselves weren’t difficult, but the challenge was documenting each step carefully. In everyday use, I’d move quickly, but here I had to slow down and show the outputs clearly. Another subtle challenge was remembering how group ownership behaves after deletion — it’s easy to overlook that Linux keeps the numeric GID even when the group name is gone.

Overall Takeaways:
This lab reinforced how central user and group management is to system security. Even though I already knew the commands, practicing them in a structured way highlighted the importance of precision and documentation. It showed how access control starts at the account and group level, and how small missteps can affect permissions across the system.

Lab 5 – Password Cracking

annotated-Kowalski-Assignment-5-Password-cracking-1

Experience:
This lab focused on testing password strength using tools like John the Ripper. Since I’ve been around Linux for a long time, I already understood how weak passwords can be exploited, but running the cracking process in a controlled lab setting made it more concrete. It was interesting to see how quickly simple passwords fell compared to stronger ones.

Key Concepts / Skills Learned:

  • Creating users with different password types (dictionary words, digits, mixed characters, symbols).
  • Exporting password hashes from /etc/shadow into a file for testing.
  • Running John the Ripper in wordlist mode with rockyou.txt.
  • Observing how password complexity directly affects cracking success.
  • Experimenting with hash formats (MD5, etc.) and troubleshooting tool installation.

Challenges Faced:
The biggest challenge was dealing with tool setup and missing wordlists. Installing dependencies and configuring John correctly took time. Another challenge was seeing how dictionary‑based passwords were flagged as weak immediately, which reinforced how easy it is to overlook security in everyday use.

Overall Takeaways:
This lab reinforced that password strength is critical. Simple or predictable passwords are easily broken, while complexity and length make a huge difference. It also showed me the importance of having the right tools installed and configured properly, since setup issues can slow down security testing.

Lab 6 – File Permissions

annotated-Kowalski-Lab-6-–-File-Permission

Experience:
This lab focused on configuring file permissions and group access. Since I’ve worked with Linux for a long time, the commands were familiar, but the lab gave me a chance to demonstrate them in a structured way. It was about showing how permissions, groups, and special bits (SGID, sticky bit) directly affect collaboration and security.

Key Concepts / Skills Learned:

  • Creating and managing groups (groupadd, usermod) and assigning users to primary and secondary groups.
  • Setting directory ownership with chown and permissions with chmod (octal and symbolic).
  • Using umask to control default permissions for new files.
  • Applying SGID to enforce group inheritance on shared directories.
  • Using the sticky bit to prevent users from deleting files they don’t own.

Challenges Faced:
The commands themselves were straightforward, but the challenge was keeping track of how permissions changed across different users and groups. Testing access from multiple accounts required careful attention to detail. Another subtle challenge was remembering how SGID and sticky bit behave differently depending on the directory setup.

Overall Takeaways:
This lab reinforced how critical permissions are to system security. Even small changes in group membership or directory settings can completely alter who has access. Practicing SGID and sticky bit showed me how Linux provides fine‑grained control for collaboration, while still protecting files from unauthorized changes.

Lab 7 – Manage Local Storage

annotated-Kowalski-Lab-7-–-Manage-Local-Storage

Experience: This lab focused on checking disks, creating partitions, and managing filesystems. Since I’ve worked with Linux storage before, the commands were familiar, but the lab gave me a chance to walk through the process in a structured way. It was about showing how to identify devices, partition them, format them, and mount them properly.

Key Concepts / Skills Learned:

  • Listing devices with ls /dev/sd* and checking partitions with fdisk -l and parted -l.
  • Adding a new virtual disk and confirming it appeared as /dev/sdb.
  • Creating a new partition with fdisk and formatting it with mkfs.ext4.
  • Mounting the partition to a directory (/cyse) and verifying with df -h.
  • Creating files on the new filesystem, unmounting, and checking the directory after.

Challenges Faced: The main challenge was keeping track of device names and making sure I didn’t accidentally overwrite existing partitions. Another challenge was documenting each step clearly, since storage management can get messy if commands aren’t precise.

Overall Takeaways: This lab reinforced how important it is to be careful with disk operations. Even though I already knew the commands, practicing them step‑by‑step showed how easy it is to make mistakes if you rush. It also highlighted how Linux gives you full control over storage, from raw devices to mounted filesystems.

Lab 8 – Shell Scripting

annotated-Kowalski-Lab-8-Shell-Scripting

Experience:
This lab focused on writing basic shell scripts. I’ve scripted in Linux before, but this exercise was about showing the fundamentals clearly: conditional statements, file checks, and directory validation. It was a good chance to demonstrate how automation saves time and reduces errors.

Key Concepts / Skills Learned:

  • Writing scripts with #!/bin/bash and making them executable.
  • Using if statements to evaluate input.
  • Checking whether a file or directory exists (-f, -d).
  • Creating files and directories automatically when they don’t exist.
  • Using redirection (>) to write output into files.

Challenges Faced:
The main challenge was catching small syntax errors. Shell scripting is unforgiving, so even a missing space or bracket can break the script.

Overall Takeaways:
This lab reinforced that scripting is essential for automation. Even simple scripts can handle repetitive tasks, and once written, they save significant time.

Lab 9 – Backup with Crontab

annotated-Kowalski_Assignment-9

Experience:
This assignment focused on automating backups with cron jobs. I’ve used cron before, but this was about packaging the process into a clear workflow: creating tar archives, compressing them, and scheduling backups.

Key Concepts / Skills Learned:

  • Creating tar archives with tar -cvf.
  • Compressing files with gzip.
  • Moving backups into /var/backups with mv.
  • Scheduling jobs with crontab -e and removing them with crontab -r.
  • Writing cleanup scripts to delete old backups when thresholds are exceeded.

Challenges Faced:
Permissions were the biggest challenge, since /var/backups is owned by root. Using sudo correctly was essential.

Overall Takeaways:
This assignment reinforced how important automation is for reliability. Backups are often overlooked, but cron ensures they happen consistently without manual effort.

Lab 10 – Networking Basics (Subnetting)

annotated-Kowalski-Networking-Basics-Subnetting

Experience:
This lab focused on subnetting and IP address calculations. I’ve worked with networking before, but this exercise formalized the math behind it: binary conversions, network ranges, and host counts.

Key Concepts / Skills Learned:

  • Converting IP addresses and subnet masks into binary.
  • Calculating network and broadcast addresses.
  • Identifying usable host ranges.
  • Understanding CIDR notation and maximum host counts.

Challenges Faced:
The challenge was keeping track of binary conversions without making off‑by‑one errors. Subnetting requires precision, and small mistakes can throw off the entire calculation.

Overall Takeaways:
This lab reinforced that networking is math‑driven but practical. Subnetting is essential for designing efficient and secure networks.

Lab 11 – Basic Network Configuration

annotated-Kowalski-Assignment-11-Basic-Network-Configuration

Experience:
This assignment built on subnetting by applying it to real IP ranges. It required calculating addresses, masks, and host counts, then documenting them clearly.

Key Concepts / Skills Learned:

  • Determining network and broadcast addresses.
  • Identifying first and last usable IPs.
  • Calculating maximum hosts per subnet.
  • Writing simple bash scripts to loop through values (for/while).

Challenges Faced:
The subnetting math was straightforward, but the challenge was documenting everything cleanly in both decimal and binary formats.

Overall Takeaways:
This assignment reinforced that networking fundamentals are critical for system administration. Understanding how IP ranges work ensures networks are configured securely and efficiently.