Welcome, young cyber hero! In this module, we will learn how to write scripts — special sets of instructions that help computers protect themselves from bad guys. Scripts are like recipes for your computer. Just like you follow a recipe to bake a cake, your computer follows a script to stay safe. We will use very simple words and lots of fun examples. Let’s start our cyber adventure!
By the end of this module, you will be able to:
Ada lives in Lagos, Nigeria. She loves playing with her robot, “Guardy”. Guardy is a smart robot that watches over her house. One day, Ada wanted Guardy to check every door at night and send her a message if any door was open. She wrote a script — a list of steps — for Guardy. The script said: “At 10pm, check each door. If a door is open, send a message to Ada.” Guardy followed the script perfectly and kept the house safe. Scripts are like that: they tell computers exactly what to do to keep us safe!
Definition: A script is a set of instructions written in a language that a computer understands.
Why important: Scripts help computers do jobs automatically, so we don’t have to do them by hand.
Simple explanation: Think of a script like a dance routine. Each step is an instruction. When you follow all steps, you complete the dance. Computers follow scripts step by step.
Real-life example: A morning alarm clock follows a script: “At 6am, ring loudly.”
School example: Your teacher might have a script for the day: “Morning prayer, then maths, then break.”
Home example: “After dinner, wash dishes, then watch TV.”
Nigerian example: A security guard at a bank has a script: “Every hour, walk around the building. If you see anything strange, call the manager.”
Script for Guardy (robot): -------------------------- 1. Wait until 10pm 2. Check front door 3. Check back door 4. If any door open -> send message 5. End
Mini summary: A script is a list of steps for a computer to follow.
Definition: Cyber security scripts are written to protect computers, networks, and data from attacks.
Why important: They work 24/7 to catch dangers, so we don’t have to watch the screen all the time.
Simple explanation: Imagine you have a pet fish. You use a timer to feed it automatically. A security script is like a timer that checks for bad guys.
Real-life example: A script can scan all files on a computer and delete any that look like a virus.
School example: A script can lock all school computers at 4pm so no one uses them after school.
Home example: A script can turn on the security camera when you leave home.
Nigerian example: In a Nigerian bank, scripts monitor every transaction. If someone tries to transfer money to a bad account, the script stops it.
Security Script Flow: Start → Check all files → Look for viruses → If virus found → Quarantine it → Alert admin
Mini summary: Cyber scripts watch over our digital world and act fast when something is wrong.
Definition: Scripting languages are special languages used to write scripts. We will focus on Python (easy to read) and Bash (used in terminals).
Why important: Knowing a scripting language lets you talk to the computer.
Simple explanation: Just like you speak English or Yoruba to talk to friends, you use Python or Bash to talk to a computer.
Real-life example: Python is used by Google and Netflix to keep systems safe.
School example: You can write a Python script to check if your homework folder is safe.
Home example: Bash scripts are used to clean up old files on your family PC.
Nigerian example: Many Nigerian tech companies use Python to build security tools.
| Language | Use | Difficulty for Kids |
|---|---|---|
| Python | General scripting, security tools | 😊 Easy |
| Bash | Command line, file management | 😐 Medium |
Mini summary: We will learn Python because it is friendly and powerful.
Definition: A Python script is a text file with instructions that end with .py.
Why important: Writing your first script is like writing your first sentence – it opens a new world.
Simple explanation: Open a notepad, type a few lines, save as .py, and run it.
Real-life example: A script that prints “Hello, World!” is the classic start.
School example: Print “Welcome to cyber class”.
Home example: Print “Don’t forget to lock the door”.
Nigerian example: Print “Aroko wa (our message) – stay safe online”.
# my_first_script.py
print("Hello, Cyber Heroes!")
print("This script keeps us safe.")
Mini summary: We type instructions in a file and run them.
Definition: A variable is like a box where you store a value (number, text, or list).
Why important: Variables help us remember things in our script.
Simple explanation: Like a jar with a label. You put candies in it and can take them out later.
Real-life example: Let age = 10. Then you can use age later to check if someone is old enough.
School example: score = 100. Use it to reward a student.
Home example: door_locked = True. Use it to decide if the alarm should be on.
Nigerian example: balance = 5000 (in Naira). Use it to check if you can buy data.
# variables example name = "Chidi" age = 10 is_secure = True print(name, "is", age, "years old.")
Mini summary: Variables store data for later use.
Definition: Conditions are like questions that have True or False answers. They help scripts decide what to do.
Why important: They allow scripts to react differently in different situations.
Simple explanation: If it rains, take an umbrella. Else, wear sunglasses. The script checks the condition.
Real-life example: If a login password is wrong, deny access.
School example: If homework is done, you can play.
Home example: If the window is open, close it.
Nigerian example: If NEPA (electricity) is on, charge your phone; else, use a power bank.
password = "secure123"
if password == "secure123":
print("Access granted!")
else:
print("Access denied.")
Mini summary: Conditions let scripts choose between actions.
Definition: A loop repeats a block of instructions several times.
Why important: They save us from writing the same instruction over and over.
Simple explanation: Like singing “Happy Birthday” three times. A loop does that for you.
Real-life example: A script that checks 1000 files one by one – it uses a loop.
School example: Count from 1 to 10 using a loop.
Home example: Repeat “check the door” 5 times.
Nigerian example: A loop can check all 50 students’ scores and find the highest.
for i in range(5):
print("Checking door", i+1)
Mini summary: Loops repeat tasks automatically.
Definition: A function is a named group of instructions that you can call (run) whenever you want.
Why important: Functions keep your script neat and reusable.
Simple explanation: Like a “make_jollof” recipe – you can use it anytime you want to cook.
Real-life example: A function “scan_for_virus” that you can call many times.
School example: A function “calculate_average” for grades.
Home example: A function “lock_doors” that locks all doors.
Nigerian example: A function “send_alert” that sends a message to the security team.
def lock_doors():
print("Locking front door")
print("Locking back door")
# call the function
lock_doors()
Mini summary: Functions are reusable blocks of code.
Definition: Scripts can read data from files and write data to files.
Why important: This helps scripts keep logs (records) of what they did.
Simple explanation: Like keeping a diary. The script writes what it checked.
Real-life example: A script reads a list of bad IP addresses and blocks them.
School example: Read a list of student names and print each one.
Home example: Write a shopping list to a file.
Nigerian example: A script reads a list of bank account numbers to monitor for fraud.
# write to file
with open("log.txt", "w") as f:
f.write("All doors checked at 10pm")
Mini summary: Files help scripts store and retrieve data.
Definition: Modules are like toolboxes full of extra functions that other people made.
Why important: They save time – we don’t have to invent everything ourselves.
Simple explanation: Like using a calculator instead of doing long addition by hand.
Real-life example: The “os” module helps interact with the computer’s operating system.
School example: The “math” module gives you sin, cos, and more.
Home example: The “datetime” module helps get the current time.
Nigerian example: Use the “requests” module to check if a website is up.
import datetime
now = datetime.datetime.now()
print("Current time:", now)
Mini summary: Modules add superpowers to your scripts.
Definition: Error handling is a way to catch mistakes (errors) without crashing the script.
Why important: It makes scripts strong and reliable.
Simple explanation: Like wearing a helmet when riding a bike – if you fall, you are safe.
Real-life example: If a file is missing, the script tells you, instead of breaking.
School example: If a student’s name is not found, print “Not found”.
Home example: If the light bulb is broken, try another one.
Nigerian example: If the network is slow, the script waits and retries.
try:
file = open("missing.txt")
except:
print("File not found, but script continues.")
Mini summary: Error handling keeps scripts from crashing.
Definition: Logging means writing down what the script did, with timestamps.
Why important: Logs help us see what happened if something goes wrong.
Simple explanation: Like a diary for the script.
Real-life example: A script logs “2026-06-27 10:00: Door checked – OK”.
School example: Log when each student finishes a test.
Home example: Log when the alarm is turned on/off.
Nigerian example: A bank script logs every ATM withdrawal.
import logging
logging.basicConfig(filename='security.log', level=logging.INFO)
logging.info('Security check completed.')
Mini summary: Logging keeps a history of actions.
Definition: Automation means letting scripts do the repetitive work for us.
Why important: Humans get tired; scripts don’t.
Simple explanation: Like a robot vacuum that cleans the floor while you play.
Real-life example: A script that automatically updates antivirus definitions.
School example: A script that backs up all homework files every Friday.
Home example: A script that turns off lights at 11pm.
Nigerian example: A script that checks the weather every morning and sends a WhatsApp message.
# pseudo-code for automation
while True:
check_for_updates()
sleep(3600) # wait 1 hour
Mini summary: Automation makes life easier and safer.
Definition: We must protect our scripts so bad guys can’t change them. Use passwords and keep them hidden.
Why important: If an evil hacker changes your script, it may help them instead.
Simple explanation: Like keeping your diary in a locked drawer.
Real-life example: Never put passwords directly in a script; use secret files.
School example: The teacher keeps the answer key in a safe.
Home example: Keep your Wi-Fi password in a secret place.
Nigerian example: Bank scripts use special “API keys” that are never shown to anyone.
# NEVER do this: password = "mysecret123" # INSTEAD, read from a secure file or environment variable.
Mini summary: Keep your scripts and secrets safe.
Definition: Testing means running your script to make sure it works as expected.
Why important: You don’t want a broken script when you need it most.
Simple explanation: Like checking your shoes before a race – make sure they are tied.
Real-life example: Run the script with test data to see if it catches a fake virus.
School example: Test a grading script with sample scores.
Home example: Test the “lock doors” script during the day.
Nigerian example: A fintech startup tests their fraud script with dummy transactions.
# simple test
assert(2 + 2 == 4)
print("Test passed!")
Mini summary: Always test your scripts before using them for real.
Step 1: Define the problem Step 2: Write pseudo‑code Step 3: Write actual code Step 4: Run and debug Step 5: Deploy
Encourage students to think of scripts as “recipes”. Use pair programming for activities. Relate every concept to a daily routine. Use the Nigerian context to make it relatable. Emphasise that making mistakes is part of learning – debugging is a superpower!
Help your child by setting up a safe computer environment where they can practice. Ask them to explain their script to you. Celebrate small wins. Remind them that cyber security is about staying safe, not just about coding.
Did you know that the first script ever written was for a computer called the “Z3” in 1941? It was used to calculate rocket trajectories!
password_attempt).
Script Execution Flow
----------------------
Start
|
V
Read input → Process → Decision?
| |
| V
| (If true) → Action A
| (If false)→ Action B
|
V
Output result
|
V
End
Loop Illustration (for 5 times) +---+ +---+ +---+ +---+ +---+ | 1 | → | 2 | → | 3 | → | 4 | → | 5 | +---+ +---+ +---+ +---+ +---+
| Feature | Python | Bash |
|---|---|---|
| Readability | Very easy | Moderate |
| Best for | General automation, security tools | File operations, system commands |
| Learning curve | Gentle | Steeper |
Congratulations! You have learned what scripts are, why they are used in cyber security, and how to write simple ones in Python. You can use variables, conditions, loops, functions, and modules. You know how to test and keep scripts safe. Remember, scripts are like your digital helpers – always there to protect you. Keep practicing and you will become a cyber hero!
python filename.py in the terminal.print() do? Match the term with its description:
| Term | Description |
|---|---|
| 1. Script | A. Repeats code |
| 2. Variable | B. Stores a value |
| 3. Loop | C. Group of instructions |
| 4. Function | D. True/False check |
| 5. Condition | E. Named reusable block |
Answers: 1-C, 2-B, 3-A, 4-E, 5-D
Scenario 1: You are a security guard at a school. You want a script that checks if the main gate is locked after 6pm. Write a simple Python script (pseudo-code) that does this.
Scenario 2: A bank wants a script that alerts the manager if a withdrawal is above ₦500,000. Write a condition that does this.
In groups of 3, brainstorm five ways a script could help a small business in Nigeria. Then, write one small script (on paper) that solves one of those problems. Present it to the class.
Write a Python script that prints your name, your age, and a message like “I love cyber security”. Then, add a condition that prints “I am a kid” if age < 18, else “I am an adult”. Run it on your computer.
Build a simple password checker! Write a script that asks the user for a password. If the password is “cyber2026”, print “Access granted”. Otherwise, print “Access denied”. Add a loop that gives the user 3 tries.
Download a text file with 10 common passwords. Write a script that reads the file and checks if any of them are “password123”. If yes, print “Weak password found!” Use a loop and a condition.
Write a script that simulates a simple alarm system. If the door is open and the time is after 8pm, print “ALARM! Door open”. Otherwise, print “All safe”. Use variables for door status and time.
All multiple-choice answers are indicated in the questions above (bold). Fill-in-the-blank answers: 1-script, 2-Variables, 3-decision/conditional, 4-loop, 5-Functions. True/False: 1-T, 2-F, 3-T, 4-F, 5-F.
In the next module, we will learn about networks and how scripts can protect them. We will explore IP addresses, firewalls, and more fun stuff. See you there, cyber heroes!
End of Module 2 · Fundamentals of Cyber Security Scripting
Welcome, young cyber hero! This is the first module of our exciting journey.
Hello there! Have you ever wondered how computers protect themselves from bad people? How do they know when a virus is trying to sneak in? The answer is scripts! In this module, we will learn what scripts are, why they are important, and how they help keep our digital world safe. We will use very simple words, lots of pictures, and fun stories. By the end, you will be able to write your very first security script. Are you ready? Let’s go!
After reading this module, you will be able to:
Once upon a time, in a small village in Nigeria, there lived a boy named Tunde. Tunde had a guard dog named Bingo. Bingo was very smart. Every night, Bingo would walk around the house and bark if he saw anything strange.
One day, Tunde’s father brought home a new robot. The robot could not bark, but it could follow instructions. Tunde’s father wrote a list of instructions for the robot: “Walk around the house. If you see a stranger, send a message to my phone.” The robot followed these instructions every night. That list of instructions was a script.
Tunde thought, “Wow! The robot does exactly what Bingo does, but it uses code!” From that day, Tunde wanted to learn how to write instructions for computers. And that is exactly what we are going to learn in this module!
Definition: A script is a set of instructions that tells a computer what to do.
Why important: Scripts help computers do jobs automatically, so we don’t have to do them by hand.
Simple explanation: Think of a script like a recipe for baking a cake. The recipe tells you step by step what to do. A script tells the computer step by step what to do.
Real-life example: A morning alarm clock follows a script: “At 6am, make a loud noise.”
School example: Your teacher has a script for the day: “Morning prayer, maths, break, English, lunch, home time.”
Home example: “After dinner, wash the plates, then watch TV.”
Nigerian example: A security guard at a bank has a script: “Every hour, walk around the building. If you see anything suspicious, call the manager.”
Script for Guardy (the robot): ------------------------------- 1. Wait until 10pm 2. Check the front door 3. Check the back door 4. If any door is open → send a message 5. End
Mini summary: A script is a list of steps for a computer to follow.
Definition: Cyber security scripts are special instructions that protect computers, networks, and data from attacks.
Why important: They work all day and night to catch dangers, so we don’t have to watch the screen all the time.
Simple explanation: Imagine you have a pet fish. You use a timer to feed it automatically. A security script is like a timer that checks for bad guys.
Real-life example: A script can scan all files on a computer and delete any that look like a virus.
School example: A script can lock all school computers at 4pm so nobody uses them after school.
Home example: A script can turn on the security camera when you leave home.
Nigerian example: In many Nigerian banks, scripts monitor every transaction. If someone tries to transfer money to a bad account, the script stops it immediately.
Security Script Flow: Start → Check all files → Look for viruses → If virus found → Quarantine it → Alert admin
Mini summary: Cyber scripts watch over our digital world and act fast when something is wrong.
Definition: A scripting language is a special language used to write scripts. We will focus on Python (very easy) and Bash (used in the terminal).
Why important: Knowing a scripting language lets you talk to the computer.
Simple explanation: Just like you speak English or Yoruba to talk to friends, you use Python or Bash to talk to a computer.
Real-life example: Python is used by companies like Google and Netflix to keep systems safe.
School example: You can write a Python script to check if your homework folder is safe.
Home example: Bash scripts are used to clean up old files on your family PC.
Nigerian example: Many Nigerian tech companies use Python to build security tools.
| Language | Use | Difficulty for Kids |
|---|---|---|
| Python | General scripting, security tools | 😊 Easy |
| Bash | Command line, file management | 😐 Medium |
Mini summary: We will learn Python because it is friendly and powerful.
Definition: A Python script is a text file with instructions that ends with .py.
Why important: Writing your first script is like writing your first sentence – it opens a new world.
Simple explanation: Open a notepad, type a few lines, save as .py, and run it.
Real-life example: The classic first script prints “Hello, World!”.
School example: Print “Welcome to cyber class”.
Home example: Print “Don’t forget to lock the door”.
Nigerian example: Print “Aroko wa (our message) – stay safe online”.
# my_first_script.py
print("Hello, Cyber Heroes!")
print("This script keeps us safe.")
Mini summary: We type instructions in a file and run them.
Definition: A variable is like a box where you store a value (number, text, or list).
Why important: Variables help us remember things in our script.
Simple explanation: Like a jar with a label. You put candies in it and can take them out later.
Real-life example: Let age = 10. Then you can use age later to check if someone is old enough.
School example: score = 100. Use it to reward a student.
Home example: door_locked = True. Use it to decide if the alarm should be on.
Nigerian example: balance = 5000 (in Naira). Use it to check if you can buy data.
# variables example name = "Chidi" age = 10 is_secure = True print(name, "is", age, "years old.")
Mini summary: Variables store data for later use.
Definition: Conditions are like questions that have True or False answers. They help scripts decide what to do.
Why important: They allow scripts to react differently in different situations.
Simple explanation: If it rains, take an umbrella. Else, wear sunglasses. The script checks the condition.
Real-life example: If a login password is wrong, deny access.
School example: If homework is done, you can play.
Home example: If the window is open, close it.
Nigerian example: If NEPA (electricity) is on, charge your phone; else, use a power bank.
password = "secure123"
if password == "secure123":
print("Access granted!")
else:
print("Access denied.")
Mini summary: Conditions let scripts choose between actions.
Definition: A loop repeats a block of instructions several times.
Why important: They save us from writing the same instruction over and over.
Simple explanation: Like singing “Happy Birthday” three times. A loop does that for you.
Real-life example: A script that checks 1000 files one by one – it uses a loop.
School example: Count from 1 to 10 using a loop.
Home example: Repeat “check the door” 5 times.
Nigerian example: A loop can check all 50 students’ scores and find the highest.
for i in range(5):
print("Checking door", i+1)
Mini summary: Loops repeat tasks automatically.
Definition: A function is a named group of instructions that you can call (run) whenever you want.
Why important: Functions keep your script neat and reusable.
Simple explanation: Like a “make_jollof” recipe – you can use it anytime you want to cook.
Real-life example: A function “scan_for_virus” that you can call many times.
School example: A function “calculate_average” for grades.
Home example: A function “lock_doors” that locks all doors.
Nigerian example: A function “send_alert” that sends a message to the security team.
def lock_doors():
print("Locking front door")
print("Locking back door")
# call the function
lock_doors()
Mini summary: Functions are reusable blocks of code.
Definition: Scripts can read data from files and write data to files.
Why important: This helps scripts keep logs (records) of what they did.
Simple explanation: Like keeping a diary. The script writes what it checked.
Real-life example: A script reads a list of bad IP addresses and blocks them.
School example: Read a list of student names and print each one.
Home example: Write a shopping list to a file.
Nigerian example: A script reads a list of bank account numbers to monitor for fraud.
# write to file
with open("log.txt", "w") as f:
f.write("All doors checked at 10pm")
Mini summary: Files help scripts store and retrieve data.
Definition: Modules are like toolboxes full of extra functions that other people made.
Why important: They save time – we don’t have to invent everything ourselves.
Simple explanation: Like using a calculator instead of doing long addition by hand.
Real-life example: The “os” module helps interact with the computer’s operating system.
School example: The “math” module gives you sin, cos, and more.
Home example: The “datetime” module helps get the current time.
Nigerian example: Use the “requests” module to check if a website is up.
import datetime
now = datetime.datetime.now()
print("Current time:", now)
Mini summary: Modules add superpowers to your scripts.
Definition: Error handling is a way to catch mistakes (errors) without crashing the script.
Why important: It makes scripts strong and reliable.
Simple explanation: Like wearing a helmet when riding a bike – if you fall, you are safe.
Real-life example: If a file is missing, the script tells you, instead of breaking.
School example: If a student’s name is not found, print “Not found”.
Home example: If the light bulb is broken, try another one.
Nigerian example: If the network is slow, the script waits and retries.
try:
file = open("missing.txt")
except:
print("File not found, but script continues.")
Mini summary: Error handling keeps scripts from crashing.
Definition: Logging means writing down what the script did, with timestamps.
Why important: Logs help us see what happened if something goes wrong.
Simple explanation: Like a diary for the script.
Real-life example: A script logs “2026-06-27 10:00: Door checked – OK”.
School example: Log when each student finishes a test.
Home example: Log when the alarm is turned on/off.
Nigerian example: A bank script logs every ATM withdrawal.
import logging
logging.basicConfig(filename='security.log', level=logging.INFO)
logging.info('Security check completed.')
Mini summary: Logging keeps a history of actions.
Definition: Automation means letting scripts do the repetitive work for us.
Why important: Humans get tired; scripts don’t.
Simple explanation: Like a robot vacuum that cleans the floor while you play.
Real-life example: A script that automatically updates antivirus definitions.
School example: A script that backs up all homework files every Friday.
Home example: A script that turns off lights at 11pm.
Nigerian example: A script that checks the weather every morning and sends a WhatsApp message.
# pseudo-code for automation
while True:
check_for_updates()
sleep(3600) # wait 1 hour
Mini summary: Automation makes life easier and safer.
Definition: We must protect our scripts so bad guys can’t change them. Use passwords and keep them hidden.
Why important: If an evil hacker changes your script, it may help them instead.
Simple explanation: Like keeping your diary in a locked drawer.
Real-life example: Never put passwords directly in a script; use secret files.
School example: The teacher keeps the answer key in a safe.
Home example: Keep your Wi-Fi password in a secret place.
Nigerian example: Bank scripts use special “API keys” that are never shown to anyone.
# NEVER do this: password = "mysecret123" # INSTEAD, read from a secure file or environment variable.
Mini summary: Keep your scripts and secrets safe.
Definition: Testing means running your script to make sure it works as expected.
Why important: You don’t want a broken script when you need it most.
Simple explanation: Like checking your shoes before a race – make sure they are tied.
Real-life example: Run the script with test data to see if it catches a fake virus.
School example: Test a grading script with sample scores.
Home example: Test the “lock doors” script during the day.
Nigerian example: A fintech startup tests their fraud script with dummy transactions.
# simple test
assert(2 + 2 == 4)
print("Test passed!")
Mini summary: Always test your scripts before using them for real.
Step 1: Define the problem Step 2: Write pseudo‑code Step 3: Write actual code Step 4: Run and debug Step 5: Deploy
Encourage students to think of scripts as “recipes”. Use pair programming for activities. Relate every concept to a daily routine. Use the Nigerian context to make it relatable. Emphasise that making mistakes is part of learning – debugging is a superpower!
Help your child by setting up a safe computer environment where they can practice. Ask them to explain their script to you. Celebrate small wins. Remind them that cyber security is about staying safe, not just about coding.
Did you know that the first script ever written was for a computer called the “Z3” in 1941? It was used to calculate rocket trajectories!
password_attempt).
Script Execution Flow
----------------------
Start
|
V
Read input → Process → Decision?
| |
| V
| (If true) → Action A
| (If false)→ Action B
|
V
Output result
|
V
End
Loop Illustration (for 5 times) +---+ +---+ +---+ +---+ +---+ | 1 | → | 2 | → | 3 | → | 4 | → | 5 | +---+ +---+ +---+ +---+ +---+
| Feature | Python | Bash |
|---|---|---|
| Readability | Very easy | Moderate |
| Best for | General automation, security tools | File operations, system commands |
| Learning curve | Gentle | Steeper |
Congratulations! You have completed Module 1. You now know what scripts are, why they are important in cyber security, and how to write a simple one. You have learned about variables, conditions, loops, functions, and modules. You also know how to keep your scripts safe and test them. Remember, every expert was once a beginner. Keep practicing and you will become a cyber hero!
python filename.py in the terminal.print() do? Match the term with its description:
| Term | Description |
|---|---|
| 1. Script | A. Repeats code |
| 2. Variable | B. Stores a value |
| 3. Loop | C. Group of instructions |
| 4. Function | D. True/False check |
| 5. Condition | E. Named reusable block |
Answers: 1-C, 2-B, 3-A, 4-E, 5-D
Scenario 1: You are a security guard at a school. You want a script that checks if the main gate is locked after 6pm. Write a simple Python script (pseudo-code) that does this.
Scenario 2: A bank wants a script that alerts the manager if a withdrawal is above ₦500,000. Write a condition that does this.
In groups of 3, brainstorm five ways a script could help a small business in Nigeria. Then, write one small script (on paper) that solves one of those problems. Present it to the class.
Write a Python script that prints your name, your age, and a message like “I love cyber security”. Then, add a condition that prints “I am a kid” if age < 18, else “I am an adult”. Run it on your computer.
Build a simple password checker! Write a script that asks the user for a password. If the password is “cyber2026”, print “Access granted”. Otherwise, print “Access denied”. Add a loop that gives the user 3 tries.
Download a text file with 10 common passwords. Write a script that reads the file and checks if any of them are “password123”. If yes, print “Weak password found!” Use a loop and a condition.
Write a script that simulates a simple alarm system. If the door is open and the time is after 8pm, print “ALARM! Door open”. Otherwise, print “All safe”. Use variables for door status and time.
All multiple-choice answers are indicated in the questions above (bold). Fill-in-the-blank answers: 1-script, 2-Variables, 3-decision/conditional, 4-loop, 5-Functions. True/False: 1-T, 2-F, 3-T, 4-F, 5-F.
In the next module, we will learn about networks and how scripts can protect them. We will explore IP addresses, firewalls, and more fun stuff. See you there, cyber heroes!
End of Module 1 · Fundamentals of Cyber Security Scripting
Welcome back, young cyber hero! This is Module 2 of our exciting course.
In Module 1, we learned what scripts are and why they are important. Now, in Module 2, we are going to go deeper. We will learn how to write scripts that make decisions, repeat actions, and talk to files. We will also learn how to keep our scripts safe and test them. By the end of this module, you will be able to write a script that acts like a security guard for your computer. Let’s dive in!
After reading this module, you will be able to:
Chidi lives in Abuja, Nigeria. His family has a smart security camera at home. The camera can do three things:
But the camera needs instructions. Chidi’s dad wrote a script that says: “If you see a person, send a message and start recording. If you don’t see anyone, do nothing. Repeat this every 5 seconds.” This script uses conditions (if/else), loops (repeat), and functions (send message, record). Chidi thought, “I want to write scripts like this!” And that is exactly what we will learn in Module 2.
Definition: A variable is like a box where you store a value (number, text, or list).
Why important: Variables help us remember things in our script.
Simple explanation: Like a jar with a label. You put candies in it and can take them out later.
Real-life example: Let age = 10. Then you can use age later to check if someone is old enough.
School example: score = 100. Use it to reward a student.
Home example: door_locked = True. Use it to decide if the alarm should be on.
Nigerian example: balance = 5000 (in Naira). Use it to check if you can buy data.
# variables example name = "Chidi" age = 10 is_secure = True print(name, "is", age, "years old.")
Mini summary: Variables store data for later use.
Definition: Conditions are like questions that have True or False answers. They help scripts decide what to do.
Why important: They allow scripts to react differently in different situations.
Simple explanation: If it rains, take an umbrella. Else, wear sunglasses. The script checks the condition.
Real-life example: If a login password is wrong, deny access.
School example: If homework is done, you can play.
Home example: If the window is open, close it.
Nigerian example: If NEPA (electricity) is on, charge your phone; else, use a power bank.
password = "secure123"
if password == "secure123":
print("Access granted!")
else:
print("Access denied.")
Mini summary: Conditions let scripts choose between actions.
Definition: A loop repeats a block of instructions several times.
Why important: They save us from writing the same instruction over and over.
Simple explanation: Like singing “Happy Birthday” three times. A loop does that for you.
Real-life example: A script that checks 1000 files one by one – it uses a loop.
School example: Count from 1 to 10 using a loop.
Home example: Repeat “check the door” 5 times.
Nigerian example: A loop can check all 50 students’ scores and find the highest.
for i in range(5):
print("Checking door", i+1)
Mini summary: Loops repeat tasks automatically.
Definition: A function is a named group of instructions that you can call (run) whenever you want.
Why important: Functions keep your script neat and reusable.
Simple explanation: Like a “make_jollof” recipe – you can use it anytime you want to cook.
Real-life example: A function “scan_for_virus” that you can call many times.
School example: A function “calculate_average” for grades.
Home example: A function “lock_doors” that locks all doors.
Nigerian example: A function “send_alert” that sends a message to the security team.
def lock_doors():
print("Locking front door")
print("Locking back door")
# call the function
lock_doors()
Mini summary: Functions are reusable blocks of code.
Definition: Scripts can read data from files and write data to files.
Why important: This helps scripts keep logs (records) of what they did.
Simple explanation: Like keeping a diary. The script writes what it checked.
Real-life example: A script reads a list of bad IP addresses and blocks them.
School example: Read a list of student names and print each one.
Home example: Write a shopping list to a file.
Nigerian example: A script reads a list of bank account numbers to monitor for fraud.
# write to file
with open("log.txt", "w") as f:
f.write("All doors checked at 10pm")
Mini summary: Files help scripts store and retrieve data.
Definition: Modules are like toolboxes full of extra functions that other people made.
Why important: They save time – we don’t have to invent everything ourselves.
Simple explanation: Like using a calculator instead of doing long addition by hand.
Real-life example: The “os” module helps interact with the computer’s operating system.
School example: The “math” module gives you sin, cos, and more.
Home example: The “datetime” module helps get the current time.
Nigerian example: Use the “requests” module to check if a website is up.
import datetime
now = datetime.datetime.now()
print("Current time:", now)
Mini summary: Modules add superpowers to your scripts.
Definition: Error handling is a way to catch mistakes (errors) without crashing the script.
Why important: It makes scripts strong and reliable.
Simple explanation: Like wearing a helmet when riding a bike – if you fall, you are safe.
Real-life example: If a file is missing, the script tells you, instead of breaking.
School example: If a student’s name is not found, print “Not found”.
Home example: If the light bulb is broken, try another one.
Nigerian example: If the network is slow, the script waits and retries.
try:
file = open("missing.txt")
except:
print("File not found, but script continues.")
Mini summary: Error handling keeps scripts from crashing.
Definition: Logging means writing down what the script did, with timestamps.
Why important: Logs help us see what happened if something goes wrong.
Simple explanation: Like a diary for the script.
Real-life example: A script logs “2026-06-27 10:00: Door checked – OK”.
School example: Log when each student finishes a test.
Home example: Log when the alarm is turned on/off.
Nigerian example: A bank script logs every ATM withdrawal.
import logging
logging.basicConfig(filename='security.log', level=logging.INFO)
logging.info('Security check completed.')
Mini summary: Logging keeps a history of actions.
Definition: Automation means letting scripts do the repetitive work for us.
Why important: Humans get tired; scripts don’t.
Simple explanation: Like a robot vacuum that cleans the floor while you play.
Real-life example: A script that automatically updates antivirus definitions.
School example: A script that backs up all homework files every Friday.
Home example: A script that turns off lights at 11pm.
Nigerian example: A script that checks the weather every morning and sends a WhatsApp message.
# pseudo-code for automation
while True:
check_for_updates()
sleep(3600) # wait 1 hour
Mini summary: Automation makes life easier and safer.
Definition: We must protect our scripts so bad guys can’t change them. Use passwords and keep them hidden.
Why important: If an evil hacker changes your script, it may help them instead.
Simple explanation: Like keeping your diary in a locked drawer.
Real-life example: Never put passwords directly in a script; use secret files.
School example: The teacher keeps the answer key in a safe.
Home example: Keep your Wi-Fi password in a secret place.
Nigerian example: Bank scripts use special “API keys” that are never shown to anyone.
# NEVER do this: password = "mysecret123" # INSTEAD, read from a secure file or environment variable.
Mini summary: Keep your scripts and secrets safe.
Definition: Testing means running your script to make sure it works as expected.
Why important: You don’t want a broken script when you need it most.
Simple explanation: Like checking your shoes before a race – make sure they are tied.
Real-life example: Run the script with test data to see if it catches a fake virus.
School example: Test a grading script with sample scores.
Home example: Test the “lock doors” script during the day.
Nigerian example: A fintech startup tests their fraud script with dummy transactions.
# simple test
assert(2 + 2 == 4)
print("Test passed!")
Mini summary: Always test your scripts before using them for real.
Definition: Debugging is the process of finding and fixing errors in your script.
Why important: Every script has bugs (mistakes). Debugging makes them perfect.
Simple explanation: Like solving a puzzle – you look for the missing piece.
Real-life example: If your script says “Hello” but you typed “Helo”, you debug by correcting the spelling.
School example: If your maths answer is wrong, you check your steps.
Home example: If the TV remote doesn’t work, you check the batteries.
Nigerian example: If a bank script fails, the developer checks the logs to find the error.
# Debugging example
# The script should print "Access granted"
# but it prints nothing. We check the condition.
password = "secure123"
if password = "secure123": # Error: should be ==
print("Access granted!")
Mini summary: Debugging is finding and fixing mistakes in your code.
Definition: Comments are notes written in the script that the computer ignores. They are for humans to read.
Why important: Comments help you and others understand what the script does.
Simple explanation: Like writing notes in a textbook.
Real-life example: # This script checks if the door is open.
School example: # This function calculates the average score.
Home example: # Turn on the lights at 6pm.
Nigerian example: # This script sends a message to the security team.
# This is a comment
print("Hello") # This is also a comment
Mini summary: Comments explain your code to humans.
Definition: We can combine variables, conditions, loops, functions, and files to create a powerful security script.
Why important: Real-world scripts use all these concepts together.
Simple explanation: Like cooking a meal – you use many ingredients.
Real-life example: A script that logs login attempts and locks an account after 3 failed attempts.
School example: A script that tracks homework submissions.
Home example: A script that monitors the temperature and sends an alert if too hot.
Nigerian example: A script that monitors bank transactions and alerts if suspicious.
# Security script example
def check_login(username, password):
# Check if username and password are correct
if username == "admin" and password == "secure123":
return True
else:
return False
# Main program
attempts = 0
while attempts < 3:
user = input("Username: ")
pwd = input("Password: ")
if check_login(user, pwd):
print("Access granted!")
break
else:
attempts += 1
print("Wrong password. Attempts left:", 3 - attempts)
if attempts == 3:
print("Account locked.")
Mini summary: Combining concepts makes powerful scripts.
Definition: Ethical hacking is using scripts to find and fix security problems, not to cause harm.
Why important: It helps keep people safe.
Simple explanation: Like being a good detective who helps people.
Real-life example: A company hires ethical hackers to test their systems.
School example: You can write a script to test if your school’s website is secure.
Home example: You can test your home Wi-Fi for vulnerabilities.
Nigerian example: Nigerian banks hire ethical hackers to protect customer data.
# Ethical hacking script (simple)
# Check if a website is using HTTPS (secure)
import requests
url = "https://example.com"
response = requests.get(url)
if response.status_code == 200:
print("Website is up and secure.")
else:
print("Website may be down or insecure.")
Mini summary: Ethical hackers use scripts to protect, not harm.
Step 1: Define the problem Step 2: Write pseudo‑code Step 3: Write actual code Step 4: Run and debug Step 5: Deploy
Encourage students to think of scripts as “recipes”. Use pair programming for activities. Relate every concept to a daily routine. Use the Nigerian context to make it relatable. Emphasise that making mistakes is part of learning – debugging is a superpower! Use the warm-up story to spark interest.
Help your child by setting up a safe computer environment where they can practice. Ask them to explain their script to you. Celebrate small wins. Remind them that cyber security is about staying safe, not just about coding. Encourage them to think about how scripts can help in daily life.
Did you know that the first computer bug was actually a real moth? In 1947, a moth got stuck in a computer and caused an error. That’s why fixing errors is called “debugging”!
password_attempt).
Script Execution Flow
----------------------
Start
|
V
Read input → Process → Decision?
| |
| V
| (If true) → Action A
| (If false)→ Action B
|
V
Output result
|
V
End
Loop Illustration (for 5 times) +---+ +---+ +---+ +---+ +---+ | 1 | → | 2 | → | 3 | → | 4 | → | 5 | +---+ +---+ +---+ +---+ +---+
Function Call Flow +-------------------+ | Main Program | | | | call function | → function does work → return to main | | +-------------------+
| Feature | Python | Bash |
|---|---|---|
| Readability | Very easy | Moderate |
| Best for | General automation, security tools | File operations, system commands |
| Learning curve | Gentle | Steeper |
| Cross-platform | Yes | Linux/Unix mostly |
| Feature | if (condition) | for/while (loop) |
|---|---|---|
| Purpose | Make a decision | Repeat an action |
| Execution | Once | Multiple times |
| Example | If password is correct, grant access. | Check all files in a folder. |
Wow! You have learned so much in Module 2. You now know how to use variables, conditions, loops, functions, and modules. You can read and write files, handle errors, and keep logs. You also know how to keep your scripts safe and test them. You even learned about ethical hacking! Remember, every expert was once a beginner. Keep practicing and you will become a cyber hero!
Welcome back, young cyber hero! This is Module 3, the final part of our foundation course.
In Modules 1 and 2, we learned the basics of scripting – variables, conditions, loops, functions, and more. Now, in Module 3, we will put everything together. We will learn how to build real security tools that can protect computers and networks. We will also learn about networks (how computers talk to each other) and encryption (how to keep messages secret). By the end of this module, you will be able to write a script that can detect a cyber attack and stop it. Are you ready to become a true cyber hero? Let’s go!
After reading this module, you will be able to:
Imagine a village in Nigeria called “Cyber Village”. In this village, every house has a computer. The computers are all connected to each other by invisible roads called networks. The village has a security team that watches over the roads.
One day, a stranger came to the village. The stranger tried to send a secret message to another house, but the security team had a script that checked all messages. The script looked for bad words and stopped the message. The village was safe because the script protected the network.
Chidi, a boy from the village, wanted to learn how to write such a script. He learned about networks, encryption, and firewalls. And now, you will learn the same things in Module 3!
Definition: A network is a group of computers that are connected to each other, like a family of computers.
Why important: Networks allow computers to share information. But they can also be attacked. Scripts protect networks.
Simple explanation: Think of a network like a telephone system. You can call your friends, but someone might eavesdrop. Scripts stop eavesdroppers.
Real-life example: The internet is a huge network of computers all over the world.
School example: The computers in your school are connected to a network so you can share files.
Home example: Your family’s computers and phones are connected to a home Wi-Fi network.
Nigerian example: A bank in Lagos has a network that connects all its branches. Scripts protect this network from hackers.
Simple Network Diagram
----------------------
[Computer 1] --- [Switch] --- [Computer 2]
| |
| |
[Computer 3] --- [Router] --- [Internet]
Mini summary: A network is a group of connected computers.
Definition: Network security scripts watch the traffic on a network and block anything suspicious.
Why important: They act like guards at the gate of a village, checking who comes in and out.
Simple explanation: Imagine a security guard at a school gate. The guard checks everyone who enters. A network script does the same for data.
Real-life example: A script can block a computer that tries to send too many requests.
School example: A script can prevent students from accessing games during class.
Home example: A script can block adult content on your home Wi-Fi.
Nigerian example: A script can protect a Nigerian university’s network from hackers.
Network Security Script Flow
----------------------------
Data enters network → Script checks data → If safe, allow through
→ If dangerous, block and log
Mini summary: Scripts protect networks by checking data and blocking bad data.
Definition: An IP address is a unique number that identifies a computer on a network, like a house address.
Why important: Scripts use IP addresses to know where data is coming from and where it is going.
Simple explanation: Just like every house has a street address, every computer on a network has an IP address.
Real-life example: 192.168.1.1 is a common IP address for home routers.
School example: The school server has an IP address that computers use to find it.
Home example: Your phone and laptop have different IP addresses on your home network.
Nigerian example: A bank’s website has an IP address that customers use to access it.
IP Address Example ------------------ 192.168.1.10 → Computer 1 192.168.1.11 → Computer 2 192.168.1.1 → Router
Mini summary: IP addresses are like house addresses for computers.
Definition: A port is a virtual door on a computer. Different services use different ports.
Why important: Scripts can open or close ports to allow or deny access.
Simple explanation: Imagine a building with many doors. Door 80 is for web pages, door 443 is for secure web pages.
Real-life example: Port 80 is used for HTTP (websites), port 443 for HTTPS (secure websites).
School example: The school’s file server uses port 21 for file transfers.
Home example: Your game console uses a specific port to connect to online games.
Nigerian example: A bank’s website uses port 443 to keep customer data safe.
Ports Diagram
-------------
[Computer]
|-- Port 80 (Web)
|-- Port 443 (Secure Web)
|-- Port 21 (File Transfer)
|-- Port 22 (Secure Shell)
Mini summary: Ports are virtual doors that scripts can control.
Definition: A firewall is a script or device that controls what data enters or leaves a network.
Why important: Firewalls block bad data from entering your computer.
Simple explanation: Like a bouncer at a club, a firewall decides who gets in and who stays out.
Real-life example: Your home router has a built-in firewall.
School example: The school’s firewall blocks social media during class.
Home example: A firewall can block unknown devices from joining your Wi-Fi.
Nigerian example: A Nigerian bank uses a firewall to protect its internal network.
Firewall Rules -------------- Allow: Port 80 (Web) from any IP Allow: Port 443 (HTTPS) from any IP Block: Port 23 (Telnet) from outside Block: Port 21 (FTP) from outside
Mini summary: Firewalls are gatekeepers that control network traffic.
Definition: Encryption is the process of converting information into a secret code to prevent unauthorised access.
Why important: It keeps data safe from hackers who might intercept it.
Simple explanation: Like writing a message in a secret language that only you and your friend understand.
Real-life example: HTTPS uses encryption to secure websites.
School example: You can encrypt your homework folder so no one else can read it.
Home example: Your Wi-Fi password is used to encrypt your internet traffic.
Nigerian example: Banks use encryption to protect customer transactions.
Encryption Process ------------------ "Hello" → [Encryption] → "&*^%$#" → [Decryption] → "Hello"
Mini summary: Encryption turns readable data into secret code.
Definition: API stands for Application Programming Interface. It’s a way for scripts to talk to other services.
Why important: APIs allow scripts to get information from other websites or services.
Simple explanation: Like ordering food at a restaurant. You tell the waiter what you want, and the waiter brings it to you.
Real-life example: A script can use the Google Maps API to get directions.
School example: A script can use a weather API to get the forecast for your school.
Home example: A script can use a news API to get the latest headlines.
Nigerian example: A script can use a payment API to process transactions in a Nigerian store.
API Communication ----------------- Script → Request to API → API processes → Script receives response
Mini summary: APIs let scripts talk to other services.
Definition: A security scanner is a script that checks for vulnerabilities in a system.
Why important: It helps find weaknesses before hackers can exploit them.
Simple explanation: Like a doctor checking your body for sickness.
Real-life example: A script can scan a website for common security holes.
School example: A script can check if student passwords are weak.
Home example: A script can check if your home router has default passwords.
Nigerian example: A Nigerian bank can use a scanner to check its website for vulnerabilities.
Scanner Flow ------------ Start → Check for weak passwords → Check for open ports → Report findings
Mini summary: Security scanners find weaknesses before hackers do.
Definition: Logging is recording events. Monitoring is watching these logs to detect problems.
Why important: Logs help you understand what happened during a security incident.
Simple explanation: Like a diary that records everything that happens in a day.
Real-life example: A script logs all login attempts and alerts if there are too many failed attempts.
School example: A script logs when students log in to the school system.
Home example: A script logs when someone tries to access your home computer.
Nigerian example: A bank monitors logs to detect fraud.
Logging Example --------------- 2026-06-27 10:00: User admin logged in from IP 192.168.1.10 2026-06-27 10:05: User admin logged out 2026-06-27 10:10: Failed login attempt from IP 10.0.0.5
Mini summary: Logging records events; monitoring watches for problems.
Definition: Ethical hacking is using hacking skills to find and fix security problems, not to cause harm.
Why important: Ethical hackers help keep people safe.
Simple explanation: Like a superhero who uses their powers to fight crime.
Real-life example: Companies hire ethical hackers to test their systems.
School example: You can be an ethical hacker by finding bugs in school websites and reporting them.
Home example: You can test your home Wi-Fi security.
Nigerian example: Nigerian banks hire ethical hackers to protect customer data.
Ethical Hacking Process ----------------------- 1. Get permission 2. Find vulnerabilities 3. Report them 4. Help fix them
Mini summary: Ethical hackers use their skills to protect, not harm.
Definition: Automation is making scripts do repetitive tasks. Security updates are patches that fix vulnerabilities.
Why important: Automated updates ensure systems are always protected.
Simple explanation: Like a robot that waters your plants every day.
Real-life example: A script that automatically downloads and installs antivirus updates.
School example: A script that updates all school computers every night.
Home example: A script that updates your apps automatically.
Nigerian example: A script that updates a bank's security software after business hours.
Automation Flow --------------- Schedule → Check for updates → Download → Install → Log success
Mini summary: Automation makes security updates easy and fast.
Definition: An alert is a notification that something suspicious has happened.
Why important: Alerts tell you when to take action.
Simple explanation: Like a fire alarm that rings when there is smoke.
Real-life example: A script sends an email alert when it detects a virus.
School example: A script alerts the IT team when a student tries to access a blocked website.
Home example: A script sends a notification to your phone when someone tries to access your computer.
Nigerian example: A script alerts a bank’s security team about a suspicious transaction.
Alert Handling -------------- Script detects suspicious activity → Sends alert → Security team investigates
Mini summary: Alerts notify you when there is a security problem.
Definition: A firewall script controls network traffic based on rules.
Why important: It blocks bad traffic and allows good traffic.
Simple explanation: Like a security guard who checks everyone’s ID.
Real-life example: A script that blocks all traffic from a specific IP address.
School example: A script that blocks access to social media during school hours.
Home example: A script that blocks devices you don’t recognise.
Nigerian example: A script that blocks traffic from known hacker IP addresses.
Firewall Script (pseudo-code)
-----------------------------
allowed_ips = ["192.168.1.1", "10.0.0.1"]
if ip in allowed_ips:
allow_traffic()
else:
block_traffic()
log_event()
Mini summary: Firewall scripts allow or block traffic based on rules.
Definition: Secure coding means writing scripts that are not vulnerable to attacks.
Why important: If your script has weaknesses, hackers can exploit them.
Simple explanation: Like building a strong house that burglars can’t break into.
Real-life example: Never trust user input directly; always validate it.
School example: When writing a script for students, make sure they can’t access files they shouldn’t.
Home example: When writing a script for home, make sure it doesn’t store passwords in plain text.
Nigerian example: Banks ensure their scripts use secure coding to protect customer data.
Secure Coding Checklist ----------------------- ☑ Validate all user input ☑ Use encryption for sensitive data ☑ Keep secrets out of code ☑ Test for common vulnerabilities
Mini summary: Secure coding keeps your scripts safe from attacks.
Definition: A security system is a collection of scripts and tools that work together to protect a network.
Why important: A single script is good, but many scripts working together are even better.
Simple explanation: Like a sports team where each player has a different role.
Real-life example: A company uses firewalls, scanners, and monitors together.
School example: A school uses scripts for login, monitoring, and updates.
Home example: You can use scripts for Wi-Fi security, parental controls, and backups.
Nigerian example: A bank uses a suite of scripts to protect its entire network.
Security System Overview ------------------------ [Firewall] → [Scanner] → [Monitor] → [Alert] → [Respond]
Mini summary: Many scripts working together create a strong security system.
Step 1: Define goal (e.g., block bad IPs) Step 2: Choose Python Step 3: Plan: Read list of bad IPs, block them Step 4: Write code Step 5: Test with sample IPs Step 6: Deploy on the network Step 7: Log events and update the list
Encourage students to think of networks as “cities” and scripts as “security guards”. Use the warm-up story to make the concepts relatable. Emphasise the importance of ethical hacking – using skills for good. Use the Nigerian context to make it relevant. Pair programming and group discussions are highly recommended.
Help your child by discussing how they use networks and the internet at home. Encourage them to think about security – what would happen if a hacker got into their device? Remind them that scripts are tools, and like any tool, they can be used for good or bad. Always encourage ethical behaviour.
Did you know that the “@” symbol was first used in emails in 1971? It was chosen because it was not used much before, so it was perfect for separating the user name from the computer name.
Network with Firewall
---------------------
[Internet] → [Firewall] → [Internal Network]
|
[Web Server]
[Email Server]
[User Computers]
Encryption Process
------------------
Plain Text: "HELLO"
↓
Encryption Algorithm
↓
Cipher Text: "KHOOR"
↓
Decryption Algorithm
↓
Plain Text: "HELLO"
API Request Flow
----------------
[Script] → [API] → [Service]
| | |
| | V
| | [Returns Data]
| V
| [API Processes]
V
[Script Receives Data]
| Feature | HTTP | HTTPS |
|---|---|---|
| Encryption | No | Yes |
| Security | Not secure | Secure |
| Port | 80 | 443 |
| Use | Old websites | Modern websites, banking |
| Feature | Firewall | Antivirus |
|---|---|---|
| Purpose | Controls network traffic | Detects and removes viruses |
| Scope | Network level | File level |
| Example | Blocks incoming connections | Scans files for malware |
Congratulations! You have completed Module 3 and the entire “Fundamentals of Cyber Security Scripting” course. You now know:
You are now ready to start your journey as a cyber security expert. Keep learning, keep coding, and always use your skills for good. The world needs more heroes like you!
Match the term with its description:
| Term | Description |
|---|---|
| 1. Network | A. Turns data into secret code |
| 2. Firewall | B. A group of connected computers |
| 3. Encryption | C. Controls network traffic |
| 4. API | D. A way for scripts to talk to services |
| 5. Scanner | E. Checks for vulnerabilities |
Answers: 1-B, 2-C, 3-A, 4-D, 5-E
Scenario 1: You are a security expert at a Nigerian bank. You notice that a lot of traffic is coming from a suspicious IP address. Write a simple script (pseudo-code) that blocks this IP address and logs the event.
Scenario 2: A small business in Lagos wants to protect its website. They want a script that checks if the website is up and sends an alert if it’s down. Write a script (pseudo-code) that does this.
In groups of 3, design a security system for a school. The system should include a firewall, a scanner, a monitor, and an alert system. Draw a diagram and write a description of how each part works. Present your design to the class.
Write a Python script that connects to a public API (like a weather API) and prints the current weather for Lagos. Then, add a condition that prints “It’s hot!” if the temperature is above 30°C.
Build a simple intrusion detection system. Write a script that monitors a log file for failed login attempts. If there are more than 3 failed attempts from the same IP address in 5 minutes, send an alert (print a message).
Write a script that scans a website for common vulnerabilities. Your script should check if the website uses HTTPS, if it has a valid SSL certificate, and if any common ports (like 21, 22, 23) are open. Print a report with your findings.
Write a script that simulates a simple firewall. The script should read a list of allowed IP addresses from a file. Then, it should check incoming traffic (simulated by user input) and allow or block it based on the list. Log all attempts.
All multiple-choice answers are indicated in the questions above (bold). Fill-in-the-blank answers: 1-network, 2-IP address, 3-port, 4-firewall, 5-Encryption, 6-API, 7-scanner, 8-Logging, 9-Ethical hacking, 10-Automation. True/False: 1-T, 2-F, 3-F, 4-F, 5-T, 6-F, 7-T, 8-F, 9-F, 10-T.
Congratulations on completing all three modules! You have a solid foundation in cyber security scripting. In the next course, we will dive deeper into web security, mobile security, and cloud security. You will learn about SQL injection, cross-site scripting, and more. Keep learning, keep coding, and always stay curious! See you in the next adventure.
End of Module 3 · Fundamentals of Cyber Security Scripting
This concludes the three-module foundation course. Well done, cyber hero!
Welcome, young cyber hero! This is Module 4, the next step in our exciting journey.
In Modules 1, 2, and 3, we learned the basics of scripting, networks, and security tools. Now, in Module 4, we will go even further. We will learn about web security (how to protect websites), database security (how to keep data safe), and mobile security (how to protect phones). We will also learn about social engineering (how hackers trick people) and how to defend against it. By the end of this module, you will be able to write scripts that can protect websites, apps, and even your friends from cyber attacks. Let’s become the ultimate cyber heroes!
After reading this module, you will be able to:
There was a small online store in Lagos called “Bisi’s Bakery”. Bisi sold cakes and pastries online. One day, a hacker tried to break into her website. The hacker used a trick called SQL injection to try and steal Bisi’s customer list.
But Bisi had a clever friend, Chidi, who had learned about web security. Chidi wrote a script that checked every visitor’s input. If the input looked dangerous, the script blocked it. The hacker was stopped, and Bisi’s bakery was safe. Chidi became a local hero!
In this module, you will learn how to write scripts like Chidi’s to protect websites and apps from bad people.
Definition: Web security is the practice of protecting websites and web applications from attacks.
Why important: Websites contain lots of personal information. Web security keeps that information safe.
Simple explanation: Imagine your website is a house. Web security is like locking the doors and windows to keep burglars out.
Real-life example: Banks use web security to protect customer accounts.
School example: Your school’s website uses security to protect student records.
Home example: Your family’s online shopping accounts need web security.
Nigerian example: Nigerian banks and online stores use web security to protect customers.
Web Security Layers
-------------------
[User] → [Firewall] → [Web Server] → [Database]
| | | |
| | | V
| | | [Encryption]
| | V
| | [Input Validation]
| V
| [SSL/HTTPS]
V
[Secure Website]
Mini summary: Web security protects websites from attacks.
Definition: SQL injection is an attack where a hacker sends bad SQL code to a website’s database to steal or change data.
Why important: It is one of the most common and dangerous attacks.
Simple explanation: Imagine you are at a restaurant. The waiter asks, “What would you like?” You say, “I want the menu AND I want to see the kitchen’s secret recipes!” That is like SQL injection.
Real-life example: In 2009, hackers used SQL injection to steal millions of credit card numbers from a major company.
School example: A hacker could use SQL injection to change their grades in the school database.
Home example: A hacker could use SQL injection to steal your family’s online shopping data.
Nigerian example: Nigerian banks have been targets of SQL injection attacks.
SQL Injection Example --------------------- Normal input: "John" Malicious input: "John' OR '1'='1' -- " This could trick the database into showing all records.
Mini summary: SQL injection is a dangerous attack that sends bad code to a database.
Definition: Defending against SQL injection means using secure coding techniques to stop bad SQL code from reaching the database.
Why important: It prevents hackers from stealing data.
Simple explanation: Like having a bouncer at a club who checks IDs before letting anyone in.
Real-life example: Using prepared statements (a secure way to talk to databases).
School example: A school website can validate all user input to prevent attacks.
Home example: A home router can block suspicious queries.
Nigerian example: A Nigerian fintech company uses input validation to protect customer data.
Input Validation Example
------------------------
user_input = "John"
if "OR" in user_input or "--" in user_input:
print("Suspicious input blocked!")
else:
print("Input is safe.")
Mini summary: Input validation and prepared statements stop SQL injection.
Definition: Cross-Site Scripting (XSS) is an attack where a hacker injects malicious scripts into a website.
Why important: XSS can steal cookies, session tokens, and other sensitive data.
Simple explanation: Imagine you post a comment on a website. The hacker writes a comment that contains a hidden script. When someone views the comment, the script runs and steals their info.
Real-life example: In 2018, British Airways suffered an XSS attack that stole customer data.
School example: A hacker could use XSS to steal students’ login cookies.
Home example: A hacker could use XSS to take over your social media account.
Nigerian example: Nigerian e-commerce sites must protect against XSS.
XSS Attack Example ------------------ User input: If the website doesn't escape this, the script will run in the browser.
Mini summary: XSS injects malicious scripts into websites.
Definition: Defending against XSS means escaping or filtering user input so that scripts don't run.
Why important: It protects users from having their data stolen.
Simple explanation: Like turning off the microphone so no one can secretly record you.
Real-life example: Using libraries that automatically escape user input.
School example: A school forum can filter out HTML tags.
Home example: A blog can escape comments before displaying them.
Nigerian example: Nigerian news websites escape comments to prevent XSS.
Escaping Example
----------------
user_input = ""
safe_input = user_input.replace("<", "<").replace(">", ">")
print(safe_input) # Output: <script>alert('Hacked!');</script>
Mini summary: Escaping user input prevents XSS attacks.
Definition: Database security is the practice of protecting the database (where data is stored) from attacks.
Why important: Databases contain valuable information like passwords, credit card numbers, and personal details.
Simple explanation: Imagine a bank vault. The vault has locks, cameras, and alarms. Database security is like that for your data.
Real-life example: Banks encrypt database backups and limit access to only authorised users.
School example: A school database stores student records and must be protected.
Home example: Your family’s password manager stores passwords in a secure database.
Nigerian example: A Nigerian hospital’s database contains patient records and must be secure.
Database Security Measures -------------------------- [Encryption] → [Access Control] → [Monitoring] → [Backups]
Mini summary: Database security protects stored data from unauthorised access.
Definition: Mobile security is the practice of protecting smartphones and tablets from attacks.
Why important: Phones contain a lot of personal information, and they are often less secure than computers.
Simple explanation: Like putting a case on your phone to protect it from drops, but for digital threats.
Real-life example: Banks use mobile apps with security features like biometric authentication.
School example: A school can use mobile security to prevent students from installing unauthorised apps.
Home example: Using a screen lock and not installing unknown apps.
Nigerian example: Many Nigerians use mobile banking, so mobile security is very important.
Mobile Security Checklist ------------------------- ☑ Use a strong screen lock ☑ Only install apps from official stores ☑ Keep your phone updated ☑ Be careful with app permissions
Mini summary: Mobile security protects phones and the data on them.
Definition: Social engineering is when hackers trick people into giving away sensitive information.
Why important: It is often easier to trick a person than to hack a computer.
Simple explanation: Imagine a stranger calls you and pretends to be your friend to get your password. That is social engineering.
Real-life example: Phishing emails that look like they are from your bank asking for your password.
School example: A hacker might call a school and pretend to be a parent to get a student’s grades.
Home example: A hacker might send a text message saying, “I need your password for security reasons.”
Nigerian example: Nigerians receive many phishing emails and SMS scams.
Social Engineering Flow ----------------------- Hacker → Tricks Person → Gets Information → Uses Information
Mini summary: Social engineering is tricking people to get their secrets.
Definition: Defending against social engineering means being aware of tricks and verifying identities.
Why important: It stops hackers from getting your information through lies.
Simple explanation: Like never giving your house keys to a stranger, no matter what they say.
Real-life example: Always verify the identity of someone asking for sensitive information.
School example: Teach students not to share passwords with anyone.
Home example: Talk to your family about not giving personal information over the phone.
Nigerian example: Nigerian banks educate customers about phishing and social engineering.
Social Engineering Defense Checklist ------------------------------------ ☑ Be suspicious of unsolicited requests ☑ Verify identities through official channels ☑ Never share passwords or OTPs ☑ Educate yourself and others
Mini summary: Awareness and verification defeat social engineering.
Definition: A web security scanner is a script that automatically checks a website for vulnerabilities.
Why important: It helps find weaknesses before hackers do.
Simple explanation: Like a health check-up for your website.
Real-life example: Tools like OWASP ZAP and Burp Suite are used to scan websites.
School example: A school can scan its website for vulnerabilities before launching it.
Home example: A blogger can scan their blog for security issues.
Nigerian example: Nigerian companies use scanners to test their e-commerce sites.
Scanner Flow ------------ Start → Check for SQL Injection → Check for XSS → Check for open ports → Report findings
Mini summary: Web security scanners find vulnerabilities automatically.
Definition: We can build a simple scanner that checks for common vulnerabilities like SQL injection and XSS.
Why important: It helps us understand how scanners work and how to defend against attacks.
Simple explanation: Like building a robot that checks every door in a building to see if it’s locked.
Real-life example: Security researchers build custom scanners for their specific needs.
School example: Students can build a scanner for their school’s website as a project.
Home example: You can build a scanner to test your own website.
Nigerian example: A Nigerian startup can build a custom scanner to test their app.
Simple Scanner Pseudo-code
--------------------------
function check_sql_injection(url):
send request with "' OR '1'='1"
if response shows error or all data:
return "Vulnerable to SQL injection"
else:
return "Safe"
Mini summary: Building a scanner helps understand web security.
Definition: Secure coding for web apps means writing code that is resistant to attacks.
Why important: It is the first line of defence against hackers.
Simple explanation: Like building a house with strong walls so burglars can’t break in.
Real-life example: Using frameworks like Django or Flask that have built-in security features.
School example: A school web project must follow secure coding practices.
Home example: A personal website should validate all user input.
Nigerian example: Nigerian developers must follow secure coding to protect user data.
Secure Coding Checklist for Web Apps ------------------------------------ ☑ Validate all user input ☑ Use prepared statements for databases ☑ Escape output to prevent XSS ☑ Use HTTPS for all pages ☑ Keep libraries and frameworks updated
Mini summary: Secure coding prevents many web vulnerabilities.
Definition: Password security is the practice of creating and managing strong passwords.
Why important: Weak passwords are the easiest way for hackers to break into accounts.
Simple explanation: Like having a strong lock on your front door.
Real-life example: Using a password manager to generate and store strong passwords.
School example: Students should use strong passwords for their school accounts.
Home example: Using a different password for each online service.
Nigerian example: Nigerian banks encourage customers to use strong passwords and OTPs.
Password Strength Checklist --------------------------- ☑ At least 12 characters long ☑ Mix of uppercase, lowercase, numbers, and symbols ☑ Not based on personal information ☑ Different for every service
Mini summary: Strong passwords protect your accounts from being hacked.
Definition: Two-factor authentication (2FA) adds a second step to log in, like a code sent to your phone.
Why important: Even if someone steals your password, they can’t log in without the second factor.
Simple explanation: Like needing both a key and a fingerprint to open a safe.
Real-life example: Many websites offer 2FA via SMS or authenticator apps.
School example: A school can use 2FA for teacher accounts.
Home example: You can enable 2FA on your email and social media accounts.
Nigerian example: Nigerian banks use 2FA for online banking.
2FA Process ----------- 1. User enters password 2. User receives a code on their phone 3. User enters the code 4. Access granted
Mini summary: 2FA adds an extra layer of security to your accounts.
Definition: A web security system combines multiple tools and scripts to protect a website.
Why important: A single tool is not enough; you need layers of defence.
Simple explanation: Like having locks, alarms, and security cameras all working together.
Real-life example: A company uses a firewall, a scanner, a monitor, and a response team.
School example: A school uses a firewall, antivirus, and security training.
Home example: You can use a firewall, a password manager, and 2FA.
Nigerian example: A Nigerian bank uses all these layers to protect customer data.
Web Security System
-------------------
[Firewall] → [Scanner] → [Monitor] → [Alert] → [Response]
| | | | |
| | | | V
| | | | [Fix Vulnerability]
| | | V
| | | [Notify Admin]
| | V
| | [Log Event]
| V
| [Generate Report]
V
[Block Bad Traffic]
Mini summary: A web security system uses multiple layers to protect a website.
Step 1: Goal – Check for SQL injection Step 2: Python Step 3: Plan – Send test payloads, check responses Step 4: Code – Write the script Step 5: Test – Use on a safe test site Step 6: Improve – Add XSS checks Step 7: Deploy – Run on your site
Encourage students to think about how they use websites and apps every day. Discuss real-world security incidents. Use the warm-up story to introduce concepts. Emphasise the importance of ethical behaviour – using security skills to protect, not harm. Use group projects to build teamwork.
Help your child by discussing online safety at home. Encourage them to use strong passwords and 2FA. Talk about social engineering and how to recognise phishing attempts. Celebrate their learning by helping them test their scripts on safe websites.
Did you know that the world's largest data breach happened in 2019, exposing 4 billion records? It was caused by a combination of SQL injection and social engineering. That's why learning web security is so important!
SQL Injection Defense --------------------- User Input → Validate → Escape → Safe Query → Database
XSS Defense ----------- User Input → Escape → Safe Output → Browser
Web Security Layers
-------------------
[Internet] → [Firewall] → [Web App] → [Database]
| | | |
| | | V
| | | [Encryption]
| | V
| | [Input Validation]
| V
| [HTTPS]
V
[Secure Website]
| Feature | SQL Injection | XSS |
|---|---|---|
| Target | Database | Browser |
| Impact | Data theft, data loss | Session hijacking, data theft |
| Defense | Input validation, prepared statements | Input escaping, output encoding |
| Feature | Password Only | Password + 2FA |
|---|---|---|
| Security Level | Low | High |
| Ease of Use | Easy | Moderate |
| Risk of Compromise | High (if weak or stolen) | Low (needs both factors) |
Congratulations! You have completed Module 4. You now have a deep understanding of web security, including:
You are now equipped to protect websites and apps from many common attacks. Keep learning, keep coding, and always use your skills for good. The digital world needs more heroes like you!
Match the term with its description:
| Term | Description |
|---|---|
| 1. SQL Injection | A. Adds a second login step |
| 2. XSS | B. An attack on the database |
| 3. 2FA | C. Tricking people to get secrets |
| 4. Social Engineering | D. An attack on the browser |
| 5. Web Scanner | E. A script that finds vulnerabilities |
Answers: 1-B, 2-D, 3-A, 4-C, 5-E
Scenario 1: You have built a website for your school. A student tells you they saw a strange pop-up on the site. You suspect XSS. Write a script (pseudo-code) that checks for XSS vulnerabilities on your site.
Scenario 2: You are working for a Nigerian bank. The bank wants to protect its customers from social engineering attacks. Write a script (pseudo-code) that sends an educational message to customers about phishing.
In groups of 3, create a presentation about a real-world cyber security incident. Discuss how the attack happened and what could have been done to prevent it. Include a demonstration of a security script that could have helped.
Write a Python script that checks if a website has HTTPS enabled. The script should connect to the website and check if it uses port 443. Print a message indicating whether the connection is secure.
Build a simple web vulnerability scanner. Write a script that checks for SQL injection and XSS vulnerabilities on a given URL. Use the requests library in Python. Test it on a safe test site like "https://testphp.vulnweb.com".
Write a script that scans a given website for common security headers (like Content-Security-Policy, X-Frame-Options, etc.). Print a report of which headers are present and which are missing. Include recommendations for improvement.
Write a script that simulates a social engineering defense system. The script should prompt the user for a secret code. If the user tries to give the code to an unauthorised person (simulated by input), the script should reject it and alert the user about social engineering.
All multiple-choice answers are indicated in the questions above (bold). Fill-in-the-blank answers: 1-Web security, 2-SQL injection, 3-XSS, 4-Database security, 5-Mobile security, 6-Social engineering, 7-web security scanner, 8-Secure coding, 9-Two-factor authentication, 10-Password security. True/False: 1-T, 2-F, 3-T, 4-F, 5-T, 6-F, 7-T, 8-T, 9-F, 10-F.
Congratulations on completing Module 4! You now have a solid understanding of web, database, and mobile security. In the next course, we will dive into advanced topics like network penetration testing, cloud security, and incident response. You will learn how to think like a hacker to better defend against them. Keep learning, keep coding, and always stay curious! See you in the next adventure.
End of Module 4 · Fundamentals of Cyber Security Scripting
This concludes the four-module foundation course. Well done, cyber hero!
Welcome, young cyber hero! This is Module 5, the final chapter of our foundation course.
In Modules 1 to 4, we learned about scripts, networks, web security, and mobile security. Now, in Module 5, we will learn about cloud security (protecting data in the cloud), incident response (what to do when an attack happens), and security automation (making scripts that run all by themselves). We will also learn about security policies (rules that keep people safe) and security awareness (teaching others about safety). By the end of this module, you will be a well-rounded cyber security expert, ready to protect the digital world. Let's become the ultimate guardians of the internet!
After reading this module, you will be able to:
In Lagos, there was a startup called "TechStars". They used a cloud service to store all their files. One day, a hacker tried to break into their cloud account. The hacker guessed a weak password and got in!
But TechStars had a smart security team. They had written a script that monitored cloud activity. The script noticed the hacker's strange behavior and immediately locked the account. It also sent an alert to the team. The hacker was stopped, and TechStars learned a valuable lesson: always use strong passwords and monitor cloud activity.
In this module, you will learn how to write scripts like that to protect cloud accounts and respond to attacks. Let's dive in!
Definition: Cloud security is the practice of protecting data, applications, and services that are stored in the cloud (on the internet).
Why important: Many companies and people store important files in the cloud. Cloud security keeps them safe from hackers.
Simple explanation: Imagine the cloud is a giant storage warehouse. Cloud security is like having guards, locks, and cameras to protect everything inside.
Real-life example: Google Drive uses cloud security to protect your files.
School example: Your school uses cloud storage for assignments and must keep it secure.
Home example: Your family uses iCloud or Google Photos to store pictures.
Nigerian example: Nigerian companies use cloud services like AWS or Azure and need cloud security.
Cloud Security Layers --------------------- [User] → [Identity Verification] → [Encryption] → [Monitoring] → [Cloud Storage]
Mini summary: Cloud security protects data stored on the internet.
Definition: Cloud services come in different forms: IaaS (Infrastructure), PaaS (Platform), and SaaS (Software).
Why important: Each model has different security responsibilities.
Simple explanation: Like renting a house (IaaS), renting a house with furniture (PaaS), or renting a fully equipped hotel room (SaaS).
Real-life example: AWS is IaaS, Google App Engine is PaaS, and Gmail is SaaS.
School example: A school using Google Classroom is using SaaS.
Home example: Using Netflix is SaaS, using a cloud server for games is IaaS.
Nigerian example: A Nigerian startup using AWS for hosting is using IaaS.
| Model | What You Get | Example |
|---|---|---|
| IaaS | Virtual computers, storage | AWS EC2, Azure VMs |
| PaaS | Platform to build apps | Google App Engine, Heroku |
| SaaS | Ready-to-use software | Gmail, Dropbox, Office 365 |
Mini summary: Cloud services come in different types: IaaS, PaaS, and SaaS.
Definition: Cloud security threats are attacks that target cloud services, like data breaches or account hijacking.
Why important: Knowing the threats helps you defend against them.
Simple explanation: Like knowing that burglars might try to break into your house, so you lock the doors.
Real-life example: In 2020, a major cloud provider had a data breach.
School example: A student might try to guess a teacher's cloud password.
Home example: A hacker might try to break into your family's cloud storage.
Nigerian example: Nigerian companies face threats like ransomware on cloud servers.
Common Cloud Threats -------------------- ☑ Data breaches ☑ Account hijacking ☑ Insecure APIs ☑ Misconfigured cloud settings
Mini summary: Cloud threats include data breaches, hijacking, and misconfigurations.
Definition: Defending against cloud threats means using strong passwords, encryption, monitoring, and access controls.
Why important: It keeps your cloud data safe from attackers.
Simple explanation: Like locking your doors, setting alarms, and having security cameras.
Real-life example: Using multi-factor authentication (MFA) for cloud accounts.
School example: A school uses MFA for teacher cloud accounts.
Home example: You enable MFA on your Google account.
Nigerian example: A Nigerian bank uses MFA and encryption for cloud banking apps.
Cloud Defense Checklist ----------------------- ☑ Use strong passwords and MFA ☑ Encrypt sensitive data ☑ Monitor for suspicious activity ☑ Regularly review permissions
Mini summary: Use strong passwords, MFA, encryption, and monitoring to defend cloud data.
Definition: Incident response is the process of handling a security attack, like a hack or data breach.
Why important: It helps you stop the attack quickly and reduce damage.
Simple explanation: Like a fire drill – you have a plan to get out safely if there's a fire.
Real-life example: A company has an incident response team that handles hacks.
School example: A school has a plan for what to do if a student's account is hacked.
Home example: You have a plan for what to do if your computer gets a virus.
Nigerian example: Nigerian banks have incident response teams to handle cyber attacks.
Incident Response Steps ----------------------- 1. Prepare (have a plan) 2. Detect (find the attack) 3. Contain (stop it from spreading) 4. Eradicate (remove the threat) 5. Recover (restore systems) 6. Learn (improve for next time)
Mini summary: Incident response is a plan to handle attacks quickly.
Definition: An incident response script automates steps like isolating a compromised system and notifying the team.
Why important: Automation speeds up response and reduces human error.
Simple explanation: Like having a robot that automatically calls the fire department when it detects smoke.
Real-life example: A script that disables a user account if suspicious activity is detected.
School example: A script that locks a student's account if too many failed login attempts.
Home example: A script that turns off your Wi-Fi if it detects an unknown device.
Nigerian example: A bank script that freezes a transaction if it seems fraudulent.
Incident Response Script (pseudo-code)
--------------------------------------
if suspicious_activity_detected():
isolate_system()
notify_team()
log_event()
wait_for_instructions()
Mini summary: Incident response scripts automate the response to attacks.
Definition: Security automation means using scripts to perform security tasks automatically, without human intervention.
Why important: It saves time and ensures security tasks are done consistently.
Simple explanation: Like having a robot that cleans your room every day while you play.
Real-life example: A script that automatically updates antivirus definitions daily.
School example: A script that backs up student data every night.
Home example: A script that changes your Wi-Fi password every month.
Nigerian example: A Nigerian company automates security patching with scripts.
Automation Flow --------------- [Schedule] → [Script] → [Task] → [Log] → [Alert if fails]
Mini summary: Automation lets scripts do security tasks without human help.
Definition: Security policies are rules that people must follow to keep systems safe, like using strong passwords or not sharing accounts.
Why important: Policies help everyone know how to behave securely.
Simple explanation: Like a school rulebook – it tells you what you can and cannot do.
Real-life example: A company policy that requires employees to change passwords every 3 months.
School example: A school policy that students cannot share their login credentials.
Home example: A family policy that no one gives out the Wi-Fi password to strangers.
Nigerian example: Nigerian banks have policies requiring customers to use strong passwords.
Policy Example -------------- Policy: All employees must use MFA. Rationale: Protects against account hijacking. Enforcement: Access is blocked if MFA is not enabled.
Mini summary: Security policies are rules that keep people and systems safe.
Definition: Security awareness means educating people about security risks and how to avoid them.
Why important: People are often the weakest link. Educated people are stronger.
Simple explanation: Like teaching your friends how to cross the road safely.
Real-life example: A company runs security awareness training for employees.
School example: A school teaches students about phishing emails.
Home example: You teach your family not to click on suspicious links.
Nigerian example: Nigerian banks run campaigns to educate customers about scams.
Awareness Topics ---------------- ☑ Recognizing phishing emails ☑ Using strong passwords ☑ Enabling MFA ☑ Reporting suspicious activity
Mini summary: Security awareness educates people to be safer online.
Definition: A security dashboard is a script or application that displays security information in a single view.
Why important: It helps security teams see everything at a glance.
Simple explanation: Like a car dashboard that shows speed, fuel, and warnings.
Real-life example: A dashboard showing real-time attacks on a company network.
School example: A dashboard showing login attempts and blocked threats.
Home example: A dashboard showing your home network's security status.
Nigerian example: A Nigerian company uses a dashboard to monitor cloud services.
Dashboard Elements
------------------
[Alerts] [Logs] [Reports] [Status]
| | | |
V V V V
[Security Dashboard]
Mini summary: A security dashboard shows all security info in one place.
Definition: Cloud logging and monitoring means recording and watching cloud activity to detect threats.
Why important: It helps you see what is happening in your cloud environment.
Simple explanation: Like having a security camera in the cloud.
Real-life example: AWS CloudTrail logs all API calls in your cloud account.
School example: A school monitors cloud storage for unusual file access.
Home example: You monitor your cloud backup for strange activity.
Nigerian example: A Nigerian company uses cloud monitoring to detect intrusions.
Cloud Monitoring Flow --------------------- [Cloud Service] → [Logs] → [Monitor] → [Alert if Suspicious]
Mini summary: Cloud logging and monitoring help detect and respond to threats.
Definition: Security orchestration means connecting different security tools to work together automatically.
Why important: It makes security more effective and less manual.
Simple explanation: Like having a team of robots that all communicate to get the job done.
Real-life example: A script that connects your firewall, scanner, and alert system.
School example: A system that automatically blocks an IP address after a scanner finds a threat.
Home example: A script that turns on your security camera when motion is detected.
Nigerian example: A Nigerian bank uses orchestration to connect their security tools.
Orchestration Flow ------------------ [Scanner] → [Firewall] → [Alert System] → [Dashboard]
Mini summary: Orchestration connects security tools to work together.
Definition: Cloud security best practices are guidelines that help keep cloud environments safe.
Why important: Following best practices prevents many common attacks.
Simple explanation: Like brushing your teeth every day to prevent cavities.
Real-life example: Using MFA, encryption, and monitoring are best practices.
School example: A school follows best practices to protect student data.
Home example: You enable MFA and use strong passwords for your cloud accounts.
Nigerian example: Nigerian companies follow best practices to protect cloud data.
Cloud Security Best Practices ----------------------------- ☑ Enable MFA ☑ Encrypt all data ☑ Monitor all activity ☑ Review permissions regularly ☑ Keep software updated
Mini summary: Follow best practices to keep your cloud environment secure.
Definition: Disaster recovery is the process of restoring systems and data after a major incident, like a ransomware attack.
Why important: It helps you recover quickly and minimize downtime.
Simple explanation: Like having a backup plan if your house gets flooded.
Real-life example: A company backs up all data to a separate location.
School example: A school backs up student records to the cloud.
Home example: You back up your family photos to an external drive.
Nigerian example: A Nigerian company has a disaster recovery plan for cloud data.
Disaster Recovery Steps ----------------------- 1. Identify critical systems 2. Back up data regularly 3. Test recovery processes 4. Have a communication plan
Mini summary: Disaster recovery helps you get back to normal after an attack.
Definition: The ultimate security system combines all the tools, scripts, and policies we've learned about.
Why important: A single tool is not enough – you need multiple layers.
Simple explanation: Like having locks, alarms, cameras, and a security guard all working together.
Real-life example: A company uses firewalls, scanners, monitors, alerts, and response teams.
School example: A school uses all these layers to protect its network.
Home example: You can use a firewall, antivirus, MFA, and a security script.
Nigerian example: A Nigerian bank uses all layers to protect customer data.
Ultimate Security System ------------------------ [Firewall] → [Scanner] → [Monitor] → [Alert] → [Response] → [Recovery]
Mini summary: The ultimate security system combines many tools and scripts.
Step 1: Goal – Monitor failed logins Step 2: AWS Step 3: Get AWS API keys Step 4: Script checks CloudTrail logs for failed logins Step 5: Test with sample logs Step 6: Deploy on production account Step 7: Add more checks over time
Encourage students to think about how they use cloud services daily. Discuss real-world incidents like data breaches. Use the warm-up story to introduce cloud security. Emphasize the importance of incident response and automation. Group activities and hands-on scripting are highly recommended.
Help your child by discussing cloud services you use at home. Encourage them to enable MFA on their accounts. Talk about security policies and why they matter. Celebrate their learning by helping them set up a simple security script on a test cloud account.
Did you know that the first ransomware attack happened in 1989? It was distributed on floppy disks. Today, ransomware attacks in the cloud are common, which is why incident response and disaster recovery are so important!
Cloud Security System
---------------------
[Internet] → [Cloud Firewall] → [Cloud App] → [Cloud Database]
| | | |
| | | V
| | | [Encryption]
| | V
| | [Input Validation]
| V
| [Access Control]
V
[Secure Cloud Environment]
Incident Response Flow ---------------------- Attack → Detect → Contain → Eradicate → Recover → Learn
Automation Flow --------------- Schedule → Script → Task → Log → Alert → Improve
| Feature | IaaS | PaaS | SaaS |
|---|---|---|---|
| Control | High | Medium | Low |
| Management | User manages OS | Provider manages OS | Provider manages everything |
| Example | AWS EC2 | Google App Engine | Gmail |
| Feature | Incident Response | Disaster Recovery |
|---|---|---|
| Purpose | Handle attacks | Recover from disasters |
| Timing | Immediate | After incident |
| Focus | Contain and eradicate | Restore systems |
Congratulations! You have completed Module 5 and the entire “Fundamentals of Cyber Security Scripting” course. You now have a comprehensive understanding of:
You are now equipped with the knowledge and skills to protect the digital world. Remember, with great power comes great responsibility. Always use your skills for good. Keep learning, keep coding, and never stop being curious. You are a true cyber hero!
Match the term with its description:
| Term | Description |
|---|---|
| 1. IaaS | A. Ready-to-use software |
| 2. PaaS | B. Virtual computers |
| 3. SaaS | C. Platform for apps |
| 4. Incident Response | D. Connecting security tools |
| 5. Orchestration | E. Handling attacks |
Answers: 1-B, 2-C, 3-A, 4-E, 5-D
Scenario 1: You are the security manager for a Nigerian e-commerce company. You discover that a hacker has accessed your cloud storage. Write an incident response script (pseudo-code) that automatically isolates the affected storage and alerts the security team.
Scenario 2: Your school uses cloud storage for student assignments. The principal wants to ensure that only teachers can access the files. Write a script (pseudo-code) that checks the permissions of all cloud folders and reports any that are misconfigured.
In groups of 3, design a cloud security system for a small business. Include a firewall, encryption, monitoring, incident response, and a dashboard. Draw a diagram and explain how each part works. Present your design to the class.
Write a Python script that connects to a cloud service (like a mock API) and checks for failed login attempts. If more than 3 failed attempts are detected, send an alert (print a message). Test your script with sample data.
Build a cloud security monitoring dashboard. Write a script that simulates monitoring cloud activity. The dashboard should display:
Use print statements to create a simple text-based dashboard.
Write a script that checks a cloud service for common security misconfigurations. Check for things like: open storage buckets, missing MFA, weak passwords, and exposed API keys. Print a report with your findings and recommendations.
Write a script that simulates a ransomware attack on a cloud environment and then automatically recovers from it. The script should:
All multiple-choice answers are indicated in the questions above (bold). Fill-in-the-blank answers: 1-Cloud security, 2-IaaS, 3-PaaS, 4-SaaS, 5-Incident response, 6-Security automation, 7-Security policies, 8-Security awareness, 9-dashboard, 10-Orchestration. True/False: 1-T, 2-F, 3-F, 4-T, 5-F, 6-T, 7-T, 8-T, 9-F, 10-T.
Congratulations on completing all five modules! You now have a solid foundation in cyber security scripting. The next course will be an advanced level where you will learn about:
Keep your curiosity alive, keep practicing, and remember: the world needs more ethical cyber heroes. See you in the next adventure!
End of Module 5 · Fundamentals of Cyber Security Scripting
This concludes the five-module foundation course. You are now a certified cyber hero! 🎉
Welcome, young cyber hero! This is Module 6, the grand finale of our course.
You have made it to the final module! In Modules 1 to 5, we learned about scripts, networks, web security, mobile security, cloud security, and incident response. Now, in Module 6, we will bring everything together. We will learn about penetration testing (ethical hacking), social engineering defense, security operations, and building a career in cyber security. We will also work on a capstone project where you will build a complete security system. By the end of this module, you will be ready to start your journey as a professional cyber security expert. Let's finish strong!
After reading this module, you will be able to:
In Lagos, there was a group of young cyber heroes who had just finished their training. They were ready to protect their country from cyber attacks. Their final test was to perform a penetration test on a mock bank system. They had to find vulnerabilities and fix them before a real hacker could.
The team worked together. They wrote scripts to scan for weaknesses, tested for SQL injection, and even simulated a social engineering attack. They found and fixed many problems. The bank was now secure. The team graduated as true cyber heroes.
In this module, you will learn how to do the same. You will become a penetration tester, a defender, and a leader. Let's begin!
Definition: Penetration testing (or pen testing) is a practice where security experts attack a system (with permission) to find weaknesses before real hackers do.
Why important: It helps organizations fix vulnerabilities before they are exploited.
Simple explanation: Like a fire drill – you practice escaping a fire so you are ready if a real fire happens.
Real-life example: Companies hire ethical hackers to test their systems.
School example: A school might test its website security to protect student data.
Home example: You can test your home Wi-Fi security to see if it's strong.
Nigerian example: Nigerian banks hire pen testers to secure their online banking.
Penetration Testing Steps ------------------------- 1. Planning 2. Reconnaissance (gathering information) 3. Scanning (finding vulnerabilities) 4. Exploitation (testing the vulnerabilities) 5. Reporting (telling what was found)
Mini summary: Penetration testing is ethical hacking to find and fix weaknesses.
Definition: Reconnaissance is the first step in a penetration test where you gather information about the target.
Why important: You need to know what you are attacking before you can find vulnerabilities.
Simple explanation: Like a detective gathering clues before solving a case.
Real-life example: A hacker might use Google to find information about a company.
School example: A student might look up a school's website to find contact details.
Home example: You might check your router's model to find known vulnerabilities.
Nigerian example: A pen tester might gather information about a Nigerian bank's online presence.
Reconnaissance Tools -------------------- ☑ WHOIS lookups ☑ DNS enumeration ☑ Google hacking ☑ Social media searches
Mini summary: Reconnaissance is gathering information about the target.
Definition: Scanning is the process of using tools to find open ports, services, and vulnerabilities in a target system.
Why important: It finds weaknesses that can be exploited.
Simple explanation: Like checking every door and window in a building to see which ones are unlocked.
Real-life example: Using a tool like Nmap to scan a network.
School example: A school IT team scans the school network for vulnerabilities.
Home example: You can scan your home network to see if any devices are vulnerable.
Nigerian example: A Nigerian company scans its network for open ports.
Scanning Flow ------------- Target IP → Scan Ports → Identify Services → Check for Vulnerabilities
Mini summary: Scanning finds vulnerabilities in a target system.
Definition: Exploitation is the step where you attempt to use a vulnerability to gain access or cause an effect.
Why important: It proves that the vulnerability is real and dangerous.
Simple explanation: Like trying to open a unlocked door to see if you can get in.
Real-life example: Using a SQL injection to get data from a database.
School example: A student might try to guess a teacher's password.
Home example: Trying to log into your neighbor's Wi-Fi with a default password.
Nigerian example: A pen tester exploits a vulnerability in a Nigerian bank's website.
Exploitation Steps ------------------ Identify Vulnerability → Craft Exploit → Execute Exploit → Gain Access
Mini summary: Exploitation is using a vulnerability to gain access.
Definition: Reporting is the final step of a penetration test where you document all findings and provide recommendations.
Why important: It helps the organization fix the vulnerabilities.
Simple explanation: Like writing a report about a science experiment – you tell what happened and what you learned.
Real-life example: A penetration testing report with findings and recommendations.
School example: A student writes a report about a security test on the school website.
Home example: You write a report about your home network security.
Nigerian example: A Nigerian company receives a report from a pen tester.
Report Structure ---------------- 1. Executive Summary 2. Methodology 3. Findings 4. Recommendations 5. Conclusion
Mini summary: Reporting documents vulnerabilities and how to fix them.
Definition: Social engineering defense means educating people and using technology to stop social engineering attacks.
Why important: People are the weakest link; defending them strengthens security.
Simple explanation: Like teaching your friends not to talk to strangers.
Real-life example: Companies run phishing simulations to train employees.
School example: A school teaches students how to recognize phishing emails.
Home example: You teach your family not to share passwords.
Nigerian example: Nigerian banks educate customers about scams.
Social Engineering Defense -------------------------- 1. Education and Awareness 2. Verification Processes 3. Security Policies 4. Technology Controls (e.g., email filters)
Mini summary: Defending against social engineering means educating and verifying.
Definition: Security operations (SecOps) is the day-to-day monitoring and response to security threats.
Why important: It ensures that threats are caught and handled quickly.
Simple explanation: Like a security team that watches cameras all day and responds to alarms.
Real-life example: A Security Operations Center (SOC) monitors networks 24/7.
School example: A school IT team monitors the network for suspicious activity.
Home example: You can set up alerts on your home router.
Nigerian example: Nigerian banks have SOCs to monitor for fraud.
Security Operations Flow ------------------------ Monitor → Detect → Analyze → Respond → Learn
Mini summary: Security operations monitor and respond to threats.
Definition: A career in cyber security involves protecting systems, networks, and data from attacks.
Why important: Cyber security is a growing field with many job opportunities.
Simple explanation: Like choosing to become a superhero who fights digital crime.
Real-life example: Many companies hire security analysts, engineers, and managers.
School example: You can start by learning scripting and networking.
Home example: You can practice by securing your home network.
Nigerian example: Nigerian companies are hiring cyber security professionals.
Career Paths in Cyber Security ------------------------------ 1. Security Analyst 2. Penetration Tester 3. Security Engineer 4. Security Architect 5. Chief Information Security Officer (CISO)
Mini summary: A cyber security career offers many opportunities to protect people.
Definition: Cyber security is a field that changes every day. Continuing education is essential.
Why important: New threats and technologies appear all the time.
Simple explanation: Like learning new levels in a video game – you keep getting better.
Real-life example: Security professionals earn certifications and attend training.
School example: You can join cyber security clubs and competitions.
Home example: You can watch online tutorials and read security blogs.
Nigerian example: Nigerian professionals attend conferences like Cyber Security Nigeria.
Learning Path ------------- Scripting → Networking → Security → Specialization → Leadership
Mini summary: Continuous learning is key to staying ahead in cyber security.
Definition: The capstone project is a final project where you use all your skills to build a comprehensive security system.
Why important: It demonstrates your ability to apply what you have learned.
Simple explanation: Like building a full house with all the skills you learned.
Real-life example: A company might build a security system with firewalls, scanners, and monitors.
School example: Your final project could be a security system for your school.
Home example: You could build a security system for your home network.
Nigerian example: A Nigerian startup could use your security system to protect their data.
Capstone Project Overview ------------------------- [Firewall] → [Scanner] → [Monitor] → [Alert] → [Response] → [Dashboard]
Mini summary: The capstone project combines everything you have learned.
Definition: Ethics in cyber security means using your skills responsibly and legally.
Why important: With great power comes great responsibility. You must never use your skills to harm others.
Simple explanation: Like having a superpower – you use it to help, not to hurt.
Real-life example: Ethical hackers always get permission before testing.
School example: You should never hack your school's system without permission.
Home example: You should never try to hack your neighbor's Wi-Fi.
Nigerian example: Nigerian cyber security professionals follow ethical guidelines.
Ethical Principles ------------------ 1. Do no harm 2. Get permission 3. Protect privacy 4. Report vulnerabilities responsibly
Mini summary: Ethics in cyber security means using your skills for good.
Definition: Emerging threats are new types of attacks that are becoming common.
Why important: You need to know about new threats to defend against them.
Simple explanation: Like knowing that a new type of flu is going around so you can take precautions.
Real-life example: Ransomware and supply chain attacks are emerging threats.
School example: Schools need to watch for new phishing techniques.
Home example: You need to watch for new types of scams.
Nigerian example: Nigerian companies watch for new fraud techniques.
Emerging Threats ---------------- ☑ Ransomware as a Service ☑ Supply Chain Attacks ☑ AI-powered attacks ☑ Deepfakes ☑ IoT vulnerabilities
Mini summary: Stay updated on emerging threats to stay safe.
Definition: Security frameworks are sets of guidelines and best practices for security.
Why important: They provide a roadmap for building secure systems.
Simple explanation: Like a recipe book – you follow the steps to make a secure system.
Real-life example: NIST and ISO 27001 are security frameworks.
School example: A school can use a framework to build a security plan.
Home example: You can use a framework to secure your home network.
Nigerian example: Nigerian companies use frameworks like NIST.
NIST Cyber Security Framework ----------------------------- 1. Identify 2. Protect 3. Detect 4. Respond 5. Recover
Mini summary: Security frameworks provide guidelines for building secure systems.
Definition: Cloud and DevOps security means securing the development and deployment of applications in the cloud.
Why important: Many companies move to the cloud, and security must be built into the development process.
Simple explanation: Like building a house – you need to make sure the materials are safe before you start building.
Real-life example: Using DevSecOps practices to integrate security into development.
School example: A school can use DevSecOps to securely develop apps.
Home example: You can use DevSecOps principles for your personal projects.
Nigerian example: Nigerian tech companies use DevSecOps for cloud apps.
DevSecOps Flow -------------- Plan → Code → Build → Test → Deploy → Monitor → Secure
Mini summary: Cloud and DevOps security integrates security into development.
Definition: The future of cyber security includes AI, quantum computing, and new attack vectors.
Why important: Understanding the future helps you prepare for the challenges ahead.
Simple explanation: Like looking at a map to plan your next adventure.
Real-life example: AI is used to detect threats automatically.
School example: Schools will use AI to monitor for cyber bullying.
Home example: Your home will have more smart devices that need security.
Nigerian example: Nigerian companies will adopt AI for security.
Future Trends ------------- ☑ AI and Machine Learning ☑ Quantum Computing ☑ Zero Trust Architecture ☑ IoT Security ☑ Automated Response
Mini summary: The future of cyber security is exciting and full of opportunities.
Step 1: Plan – Scope, permission, rules Step 2: Recon – WHOIS, DNS, social media Step 3: Scan – Nmap, vulnerability scanners Step 4: Exploit – SQL injection, XSS, etc. Step 5: Report – Findings, impact, fixes
Encourage students to think about their future careers in cyber security. Use the capstone project as a practical assessment. Discuss ethics in detail – emphasize the importance of using skills for good. Use real-world incidents to illustrate concepts. Encourage continuous learning and curiosity.
Help your child explore cyber security as a career. Encourage them to participate in competitions and online courses. Discuss the importance of ethics and using skills responsibly. Celebrate their achievements and encourage them to keep learning.
Did you know that the world's first cyber attack happened in 1988? It was a worm called "Morris Worm" that caused millions of dollars in damage. Today, cyber attacks are much more common, which is why cyber security is so important.
Penetration Testing Process --------------------------- Plan → Recon → Scan → Exploit → Report → Fix
Security Operations Flow ------------------------ Monitor → Detect → Analyze → Respond → Improve
Career Path in Cyber Security ----------------------------- Beginner → Junior → Analyst → Senior → Manager → CISO
| Feature | Penetration Testing | Vulnerability Scanning |
|---|---|---|
| Purpose | Find and exploit vulnerabilities | Find vulnerabilities |
| Depth | Deep | Shallow |
| Manual | Often manual | Automated |
| Cost | Expensive | Cheaper |
| Feature | Security Analyst | Penetration Tester |
|---|---|---|
| Role | Monitor and respond | Find vulnerabilities |
| Focus | Defense | Offense |
| Skills | Monitoring, response | Hacking, testing |
Congratulations! You have completed Module 6 and the entire “Fundamentals of Cyber Security Scripting” course. You now have a deep understanding of:
You are now ready to start your career as a cyber security professional. Remember to always use your skills for good, keep learning, and never stop exploring. The digital world needs more heroes like you!
Match the term with its description:
| Term | Description |
|---|---|
| 1. Penetration Testing | A. Guidelines for security |
| 2. Reconnaissance | B. Finding vulnerabilities |
| 3. Scanning | C. Ethical hacking |
| 4. Exploitation | D. Gathering information |
| 5. Reporting | E. Using vulnerabilities |
| 6. Framework | F. Documenting findings |
Answers: 1-C, 2-D, 3-B, 4-E, 5-F, 6-A
Scenario 1: You are a penetration tester hired by a Nigerian bank. You have found a SQL injection vulnerability. Write a script (pseudo-code) that demonstrates the vulnerability and then write a report summary of what you found and how to fix it.
Scenario 2: You are the security operations lead at a Nigerian company. You notice a social engineering attack targeting your employees. Write a script (pseudo-code) that sends an alert to the security team and educates employees about the attack.
In groups of 3, design a complete security system for a small business. Include a firewall, scanner, monitor, alert system, and response plan. Draw a diagram and explain how each part works. Present your design to the class.
Write a Python script that simulates a simple penetration test. The script should:
Test it on a safe test environment.
Build a complete security dashboard. Write a script that collects data from multiple sources (firewall logs, scanner results, monitor alerts) and displays them in a single text-based dashboard. The dashboard should show:
Write a script that performs a basic penetration test on a website. The script should check for:
Generate a detailed report with recommendations.
Write a script that simulates a full penetration test lifecycle. The script should:
All multiple-choice answers are indicated in the questions above (bold). Fill-in-the-blank answers: 1-Penetration testing, 2-Reconnaissance, 3-Scanning, 4-Exploitation, 5-Reporting, 6-Social engineering defense, 7-Security operations, 8-Ethics, 9-Security frameworks, 10-DevSecOps. True/False: 1-F, 2-T, 3-T, 4-F, 5-F, 6-F, 7-F, 8-T, 9-F, 10-T.
Congratulations on completing all six modules! You have a solid foundation in cyber security scripting. The next course will be an advanced specialization where you will choose a path:
Keep your curiosity alive, keep practicing, and remember: the world needs more ethical cyber heroes. See you in the next adventure!
End of Module 6 · Fundamentals of Cyber Security Scripting
This concludes the six-module foundation course. You are now a certified cyber hero! 🎉
Welcome, young cyber hero! This is Module 7, our special bonus module.
You have completed six modules and learned so much! But the world of cyber security is vast, and there is always more to learn. In this bonus module, we will explore advanced scripting techniques, security automation at scale, threat intelligence, and how to build your own security tools. We will also learn about cyber security competitions and how to stay motivated. This module is for those who want to go even further. Let's continue our adventure!
After reading this module, you will be able to:
Chidi, our hero from Lagos, had completed his training. He was now a skilled cyber security professional. But he didn't stop there. He wanted to build his own tools, participate in competitions, and help even more people.
He started building a tool that could automatically scan for vulnerabilities and send reports. He joined a cyber security competition and won first place. He also started teaching others about security. Chidi became a true leader in the cyber security community.
In this module, you will learn how to take your skills to the next level, just like Chidi. Let's go!
Definition: Libraries are collections of pre-written code that you can use to make your scripts more powerful.
Why important: Libraries save time and add advanced features.
Simple explanation: Like using a toolbox with specialized tools instead of a basic hammer.
Real-life example: Using the 'requests' library to make HTTP requests.
School example: Using the 'math' library for complex calculations.
Home example: Using the 'datetime' library to get the current time.
Nigerian example: Using the 'pywhatkit' library to send WhatsApp messages.
# Using the requests library
import requests
response = requests.get('https://api.example.com/data')
print(response.json())
Mini summary: Libraries add powerful features to your scripts.
Definition: APIs allow your scripts to communicate with other services and get data.
Why important: APIs let you integrate with third-party services.
Simple explanation: Like ordering food from a restaurant – you give your order and they bring you food.
Real-life example: Using the Google Maps API to get directions.
School example: Using a weather API to get the forecast for school.
Home example: Using a news API to get headlines.
Nigerian example: Using a payment API to process transactions.
# Using an API import requests url = 'https://api.weather.com/forecast?city=Lagos' response = requests.get(url) data = response.json() print(data['forecast'])
Mini summary: APIs let your scripts talk to other services.
Definition: Automation at scale means running scripts that handle large numbers of tasks automatically.
Why important: It saves time and ensures consistency across many systems.
Simple explanation: Like having a robot that cleans thousands of rooms instead of just one.
Real-life example: A script that updates software on 10,000 computers.
School example: A script that backs up all student data across multiple schools.
Home example: A script that manages all your smart home devices.
Nigerian example: A script that monitors ATMs across all bank branches.
# Automation at scale (pseudo-code)
for server in all_servers:
update_security(server)
log_event(server)
Mini summary: Automation at scale handles many tasks automatically.
Definition: Threat intelligence is information about threats that can help you defend against them.
Why important: It helps you prepare for attacks before they happen.
Simple explanation: Like a weather forecast that helps you prepare for a storm.
Real-life example: A company uses threat intelligence to block known hacker IP addresses.
School example: A school uses threat intelligence to block phishing websites.
Home example: You use threat intelligence to block malicious apps.
Nigerian example: A bank uses threat intelligence to prevent fraud.
Threat Intelligence Flow ------------------------ Collect Data → Analyze → Identify Threats → Block Threats
Mini summary: Threat intelligence helps you know and block threats.
Definition: Building your own tools means creating custom scripts and applications for your specific security needs.
Why important: Off-the-shelf tools may not fit your exact needs.
Simple explanation: Like building a custom desk instead of buying a ready-made one.
Real-life example: A company builds a custom vulnerability scanner.
School example: A school builds a custom attendance monitoring system.
Home example: You build a custom script to monitor your home network.
Nigerian example: A Nigerian fintech builds a custom fraud detection tool.
Tool Building Steps ------------------- 1. Identify need 2. Design solution 3. Code tool 4. Test tool 5. Deploy and maintain
Mini summary: Building your own tools gives you exactly what you need.
Definition: CTF (Capture The Flag) competitions are challenges where you solve security puzzles to find flags.
Why important: They help you practice and learn new skills in a fun way.
Simple explanation: Like a treasure hunt for cyber security.
Real-life example: The DEF CON CTF is a famous competition.
School example: Your school can organize a CTF competition.
Home example: You can play CTF challenges online.
Nigerian example: Nigerian universities participate in CTF competitions.
CTF Challenge Types ------------------- ☑ Web security ☑ Cryptography ☑ Reverse engineering ☑ Forensics ☑ Binary exploitation
Mini summary: CTF competitions are fun ways to practice security skills.
Definition: Staying motivated means keeping your enthusiasm and continuing to learn, even when things get tough.
Why important: Cyber security is always changing, and you need to keep up.
Simple explanation: Like training for a marathon – you need to keep running every day.
Real-life example: Security professionals join communities and attend conferences.
School example: Join a cyber security club at school.
Home example: Set weekly learning goals for yourself.
Nigerian example: Join Nigerian cyber security groups like Cybersafe.
Motivation Tips --------------- ☑ Set small goals ☑ Join communities ☑ Celebrate achievements ☑ Keep learning new things
Mini summary: Staying motivated helps you succeed in cyber security.
Definition: Security research is the process of discovering new vulnerabilities and ways to protect against them.
Why important: Research pushes the field forward and helps everyone stay safe.
Simple explanation: Like an explorer discovering new lands.
Real-life example: Researchers find bugs in popular software and get paid for it.
School example: A student finds a vulnerability in a school app and reports it.
Home example: You research the security of your home devices.
Nigerian example: Nigerian researchers find vulnerabilities in local apps.
Research Process ---------------- 1. Identify area of interest 2. Study existing knowledge 3. Experiment and test 4. Document findings 5. Share with the community
Mini summary: Security research discovers new ways to protect systems.
Definition: Open source security tools are tools whose source code is available for anyone to use and modify.
Why important: They are free, transparent, and often very powerful.
Simple explanation: Like sharing toys with your friends – everyone can use and improve them.
Real-life example: Tools like Wireshark, Nmap, and Metasploit are open source.
School example: A school uses open source tools to save money.
Home example: You use open source tools to secure your home network.
Nigerian example: Nigerian companies use open source tools like OSSEC.
Popular Open Source Security Tools ---------------------------------- ☑ Wireshark – Network analysis ☑ Nmap – Port scanning ☑ Metasploit – Exploitation ☑ OSSEC – Intrusion detection ☑ OpenVAS – Vulnerability scanning
Mini summary: Open source tools are free and powerful.
Definition: Infrastructure as Code (IaC) means managing cloud resources using scripts and configuration files.
Why important: It makes cloud management consistent and repeatable.
Simple explanation: Like building a house from a blueprint – you can build it the same way every time.
Real-life example: Using Terraform to provision cloud resources.
School example: A school uses IaC to set up cloud labs for students.
Home example: You use IaC to manage your home cloud setup.
Nigerian example: A Nigerian company uses Terraform for AWS resources.
IaC Example (pseudo-code)
-------------------------
resource "aws_instance" "web" {
ami = "ami-12345"
instance_type = "t2.micro"
security_groups = ["web-sg"]
}
Mini summary: IaC manages cloud resources with scripts.
Definition: Security metrics are measurements that show how well your security is working.
Why important: You need to know if your security is improving.
Simple explanation: Like a report card that shows your progress.
Real-life example: A company tracks the number of blocked attacks.
School example: A school tracks how many phishing emails are reported.
Home example: You track the number of security incidents in your network.
Nigerian example: A bank tracks the number of fraudulent transactions stopped.
Common Security Metrics ----------------------- ☑ Number of blocked threats ☑ Time to respond to incidents ☑ Number of vulnerabilities found ☑ Percentage of systems patched
Mini summary: Security metrics measure your security performance.
Definition: Secure coding in practice means writing code with security in mind every day.
Why important: It prevents vulnerabilities from being introduced in the first place.
Simple explanation: Like using safe habits every day, not just sometimes.
Real-life example: A developer always validates input and uses prepared statements.
School example: A student follows secure coding practices for their project.
Home example: You follow secure coding for your personal projects.
Nigerian example: A Nigerian developer follows OWASP guidelines.
Secure Coding Habits -------------------- ☑ Validate all input ☑ Use prepared statements ☑ Escape output ☑ Use encryption ☑ Keep libraries updated
Mini summary: Secure coding habits prevent vulnerabilities.
Definition: Cyber security communities are groups of people who share knowledge and support each other.
Why important: They help you learn, find jobs, and stay motivated.
Simple explanation: Like having a team of friends who help you with your homework.
Real-life example: Communities like OWASP and ISACA.
School example: Join a cyber security club at your school.
Home example: Join online forums like Reddit's r/netsec.
Nigerian example: Join the Nigerian Cyber Security Association.
Community Benefits ------------------ ☑ Learning from others ☑ Finding mentors ☑ Job opportunities ☑ Support and motivation
Mini summary: Communities help you grow and stay motivated.
Definition: Teaching others means sharing your security knowledge with friends, family, and colleagues.
Why important: Sharing knowledge makes everyone safer.
Simple explanation: Like teaching your friend how to ride a bike.
Real-life example: A security professional trains their team.
School example: You teach your classmates about phishing.
Home example: You teach your family about strong passwords.
Nigerian example: A Nigerian expert trains local startups.
Teaching Tips ------------- ☑ Use simple examples ☑ Be patient ☑ Encourage questions ☑ Provide resources
Mini summary: Teaching others helps everyone stay safe.
Definition: Your role as a cyber hero is to protect people and systems from cyber threats.
Why important: You are part of a global community working to make the digital world safer.
Simple explanation: Like being a superhero for the internet.
Real-life example: Security professionals protect millions of users.
School example: You can protect your school's systems.
Home example: You can protect your family's devices.
Nigerian example: You can protect Nigerian businesses and citizens.
Your Role --------- Protect → Educate → Innovate → Lead
Mini summary: You are a cyber hero who protects the digital world.
Step 1: Need – Scan for open ports Step 2: Research – Nmap exists but we want a simple script Step 3: Design – Use Python's socket library Step 4: Develop – Write the script Step 5: Test – Scan localhost Step 6: Deploy – Use it on your network Step 7: Maintain – Add more features
Encourage students to explore beyond the curriculum. Introduce them to CTF platforms like Hack The Box or TryHackMe. Discuss the importance of communities and networking. Emphasize that cyber security is a journey, not a destination. Encourage students to teach others.
Support your child's interest by providing resources like books and online courses. Encourage them to participate in competitions and communities. Help them set learning goals and celebrate their achievements. Remind them that cyber security is about helping others.
Did you know that the first computer virus was created by a 15-year-old? His name was Richard Skrenta, and he created the "Elk Cloner" virus in 1982. Today, young people like you are making a big difference in cyber security!
Automation at Scale ------------------- [Script] → [1000 Servers] → [Update] → [Log] → [Report]
Threat Intelligence Flow ------------------------ [Collect] → [Analyze] → [Threats] → [Block] → [Protect]
Tool Building Cycle ------------------- [Need] → [Design] → [Code] → [Test] → [Deploy] → [Maintain]
| Feature | Open Source | Proprietary |
|---|---|---|
| Cost | Free | Expensive |
| Transparency | Full | Limited |
| Customization | High | Low |
| Support | Community | Vendor |
| Feature | CTF | Real-World |
|---|---|---|
| Environment | Controlled | Unpredictable |
| Complexity | Varies | High |
| Legal Issues | None | Important |
| Fun Factor | High | Moderate |
Congratulations! You have completed Module 7 and the entire "Fundamentals of Cyber Security Scripting" course. You now have a deep understanding of:
You are now ready to take on the world of cyber security. Remember to always use your skills for good, keep learning, and never stop exploring. The digital world needs more heroes like you!
Match the term with its description:
| Term | Description |
|---|---|
| 1. Library | A. Information about threats |
| 2. API | B. Security competition |
| 3. Threat Intelligence | C. Collection of pre-written code |
| 4. CTF | D. Way to talk to services |
| 5. Open Source | E. Free and transparent software |
Answers: 1-C, 2-D, 3-A, 4-B, 5-E
Scenario 1: You are a security lead at a Nigerian bank. You want to build a custom fraud detection tool. Write a plan (pseudo-code) for the tool. Include what it will do and how it will work.
Scenario 2: You want to participate in a CTF competition. You need to practice. Write a script (pseudo-code) that solves a simple cryptography challenge (like a Caesar cipher).
In groups of 3, create a presentation about a security tool you would like to build. Explain the problem it solves, how it works, and how it would help people. Present your idea to the class.
Write a Python script that uses an API to get weather data for Lagos. Then, add a condition that prints "It's hot!" if the temperature is above 30°C.
Build a custom security dashboard. Write a script that collects data from a mock API (you can simulate it) and displays it in a dashboard. Include:
Write a script that performs threat intelligence. Use an API (like VirusTotal) to check if a given IP address is malicious. Print a report with your findings.
Write a script that builds a complete security tool. The tool should:
Test it on a safe network.
All multiple-choice answers are indicated in the questions above (bold). Fill-in-the-blank answers: 1-library, 2-API, 3-Automation at scale, 4-Threat intelligence, 5-CTF, 6-Open source, 7-Infrastructure as Code, 8-Security metrics, 9-Secure coding, 10-Communities. True/False: 1-T, 2-F, 3-F, 4-T, 5-F, 6-T, 7-F, 8-F, 9-T, 10-F.
Congratulations on completing all seven modules! You have a solid foundation in cyber security scripting. The next course will be an advanced specialization where you will choose a path:
Keep your curiosity alive, keep practicing, and remember: the world needs more ethical cyber heroes. See you in the next adventure!
End of Module 7 · Fundamentals of Cyber Security Scripting
This concludes the seven-module foundation course. You are now a certified cyber hero! 🎉
Welcome, young cyber hero! This is Module 8, our special advanced bonus module.
You have already completed seven modules and learned so much! But the world of cyber security is like a vast ocean—there is always more to explore. In this bonus module, we will dive into advanced security automation, machine learning for security, blockchain security, quantum computing threats, and how to become a security leader. We will also explore ethical dilemmas and how to build a security startup. This module is for those who want to become true masters. Let's continue our journey!
After reading this module, you will be able to:
In Lagos, there was a young woman named Amara. She had completed her training in cyber security and was working for a bank. But Amara had a vision. She wanted to use artificial intelligence to predict cyber attacks before they happened.
She spent months building a system that analyzed patterns and flagged potential threats. Her system was so good that it stopped several attacks before they could do any damage. Amara became a leader in her field and started teaching others.
In this module, you will learn about advanced topics like AI, blockchain, and leadership. You too can become a visionary like Amara!
Definition: Advanced automation means using sophisticated scripts and tools to handle complex security tasks. Orchestration means connecting different tools to work together.
Why important: It makes security faster, more efficient, and less error-prone.
Simple explanation: Like having a team of robots that communicate to build a car.
Real-life example: A company uses SOAR (Security Orchestration, Automation, and Response) platforms.
School example: A school automates the process of updating all computers.
Home example: You connect your security camera, alarm, and lights to work together.
Nigerian example: A Nigerian bank uses orchestration to connect its fraud detection systems.
Orchestration Flow ------------------ [Scanner] → [Firewall] → [Alert System] → [Dashboard] → [Response]
Mini summary: Advanced automation and orchestration make security smarter.
Definition: Machine learning (ML) is a way for computers to learn from data and make predictions.
Why important: ML can detect threats that traditional tools might miss.
Simple explanation: Like teaching a computer to recognize a cat by showing it many pictures of cats.
Real-life example: Google uses ML to detect spam emails.
School example: A school uses ML to detect cyberbullying.
Home example: Your email uses ML to filter spam.
Nigerian example: A Nigerian fintech uses ML to detect fraudulent transactions.
ML Security Flow ---------------- Data → Train Model → Test Model → Deploy → Detect Threats
Mini summary: Machine learning helps computers learn to detect threats.
Definition: Blockchain is a technology that stores data in blocks that are linked together securely.
Why important: Blockchain is used in cryptocurrencies and secure record-keeping.
Simple explanation: Like a digital notebook that cannot be changed after something is written.
Real-life example: Bitcoin uses blockchain to record transactions.
School example: A school could use blockchain to store student records securely.
Home example: You could use a blockchain-based app to store important documents.
Nigerian example: Nigerian startups are using blockchain for secure land records.
Blockchain Structure
--------------------
[Block 1] → [Block 2] → [Block 3] → [Block 4]
| | | |
V V V V
[Hash] [Hash] [Hash] [Hash]
Mini summary: Blockchain creates secure, unchangeable records.
Definition: Quantum computing is a new type of computing that is much faster than traditional computers.
Why important: Quantum computers could break current encryption, making many security systems useless.
Simple explanation: Like having a super-fast calculator that can solve problems in seconds that would take years.
Real-life example: Researchers are developing quantum-safe encryption.
School example: Schools will need to learn about quantum-safe security.
Home example: In the future, your devices may need quantum-safe updates.
Nigerian example: Nigerian companies are starting to prepare for quantum threats.
Quantum Threat -------------- Classical Encryption → Quantum Computer → Broken Encryption
Mini summary: Quantum computers could break current encryption.
Definition: Ethical dilemmas are situations where there is no clear right or wrong choice.
Why important: Security professionals often face difficult ethical decisions.
Simple explanation: Like having to choose between two good (or bad) options.
Real-life example: Should a security researcher disclose a vulnerability to the public or to the company first?
School example: Should a student report a friend who is hacking?
Home example: Should you monitor your family's online activity?
Nigerian example: Nigerian security professionals face dilemmas about privacy vs. security.
Ethical Decision Flow --------------------- Identify Dilemma → Consider Options → Evaluate Consequences → Choose
Mini summary: Ethical dilemmas require careful thought and good judgment.
Definition: A security startup is a new company that creates security products or services.
Why important: Startups bring new ideas and solutions to the market.
Simple explanation: Like building a lemonade stand, but for security products.
Real-life example: Many successful security companies started as small startups.
School example: Students can start a security club to build products.
Home example: You can build a security tool and share it online.
Nigerian example: Nigerian entrepreneurs are starting security startups.
Startup Steps ------------- Idea → Research → Build Product → Test → Launch → Grow
Mini summary: Startups bring new security solutions to the world.
Definition: Security leadership means guiding teams and organizations to stay secure.
Why important: Good leaders make sure security is a priority.
Simple explanation: Like a captain of a ship – you steer the team in the right direction.
Real-life example: A Chief Information Security Officer (CISO) leads a security team.
School example: A teacher who leads a cyber security club.
Home example: You lead your family by teaching them security.
Nigerian example: Nigerian organizations need security leaders to protect data.
Leadership Qualities -------------------- ☑ Communication ☑ Vision ☑ Integrity ☑ Empathy ☑ Resilience
Mini summary: Security leaders guide and protect their teams.
Definition: Incident response at scale means handling many security incidents simultaneously.
Why important: Large organizations face thousands of incidents every day.
Simple explanation: Like a hospital emergency room handling many patients at once.
Real-life example: A cloud provider handles incidents for millions of customers.
School example: A large school district handles incidents across many schools.
Home example: You handle incidents on multiple devices.
Nigerian example: A Nigerian telecom handles incidents for millions of users.
Incident Response at Scale -------------------------- [Incidents] → [Triage] → [Prioritize] → [Respond] → [Learn]
Mini summary: Incident response at scale handles many incidents efficiently.
Definition: Security awareness programs are initiatives to educate people about security.
Why important: Educated people are the best defense against many attacks.
Simple explanation: Like a school program that teaches students about fire safety.
Real-life example: A company runs monthly security training for employees.
School example: A school has a security awareness week.
Home example: You teach your family about phishing.
Nigerian example: Nigerian banks run awareness campaigns for customers.
Awareness Program Steps ----------------------- Assess Needs → Develop Content → Deliver Training → Evaluate → Improve
Mini summary: Awareness programs educate people to prevent attacks.
Definition: Cyber insurance helps organizations recover from cyber attacks. Risk management is the process of identifying and reducing risks.
Why important: You can't prevent all attacks, but you can prepare.
Simple explanation: Like having car insurance – you hope you never need it, but you're glad you have it.
Real-life example: A company buys cyber insurance to cover losses from a breach.
School example: A school has insurance for data breaches.
Home example: Your family can get cyber insurance for identity theft.
Nigerian example: Nigerian companies are starting to buy cyber insurance.
Risk Management Process ----------------------- Identify Risks → Assess Impact → Mitigate → Monitor → Review
Mini summary: Cyber insurance and risk management help you prepare for attacks.
Definition: Advanced cryptography uses complex algorithms to secure data.
Why important: It protects data from even the most sophisticated attacks.
Simple explanation: Like a secret code that is almost impossible to crack.
Real-life example: AES-256 encryption used by governments.
School example: A school uses encryption to protect student data.
Home example: You use encryption for your Wi-Fi and files.
Nigerian example: Nigerian banks use advanced cryptography for transactions.
Cryptography Flow ----------------- Plain Text → Encryption → Cipher Text → Decryption → Plain Text
Mini summary: Advanced cryptography protects data with strong algorithms.
Definition: OSINT is the practice of gathering information from publicly available sources.
Why important: It helps in reconnaissance and threat intelligence.
Simple explanation: Like being a detective who uses public records and news.
Real-life example: A company uses OSINT to monitor for data breaches.
School example: Students use OSINT to gather information for a project.
Home example: You use OSINT to check if your email has been compromised.
Nigerian example: Nigerian researchers use OSINT to track scams.
OSINT Sources ------------- ☑ Social media ☑ Public records ☑ News articles ☑ Domain registrations
Mini summary: OSINT gathers information from public sources.
Definition: Security testing ensures that security controls are working correctly.
Why important: You need to validate that your security is effective.
Simple explanation: Like checking that your locks actually work.
Real-life example: A company runs regular security audits.
School example: A school tests its security by running drills.
Home example: You test your network security by scanning for open ports.
Nigerian example: Nigerian companies conduct security assessments.
Testing Flow ------------ Plan → Execute Tests → Analyze Results → Fix Issues → Retest
Mini summary: Security testing validates that your security works.
Definition: Bug bounties are programs that reward people for finding vulnerabilities. Responsible disclosure means reporting vulnerabilities in a way that gives organizations time to fix them.
Why important: Bug bounties incentivize researchers to find vulnerabilities.
Simple explanation: Like a treasure hunt where you get a reward for finding a bug.
Real-life example: Google runs a bug bounty program.
School example: A school could offer a small reward for finding vulnerabilities.
Home example: You could report a vulnerability to a company and get a reward.
Nigerian example: Nigerian companies are starting bug bounty programs.
Responsible Disclosure Process ------------------------------ Find Vulnerability → Report to Organization → Wait for Fix → Public Disclosure
Mini summary: Bug bounties and responsible disclosure help fix vulnerabilities.
Definition: Becoming a master means continuously learning, leading, and innovating.
Why important: The field is always evolving, and masters lead the way.
Simple explanation: Like becoming a black belt in martial arts – you keep training and teaching.
Real-life example: Top security experts speak at conferences and write books.
School example: You can become a leader in your school's security club.
Home example: You can mentor others and share your knowledge.
Nigerian example: Nigerian security experts are becoming global leaders.
Mastery Path ------------ Learn → Practice → Teach → Innovate → Lead
Mini summary: Becoming a master requires continuous learning and leadership.
Step 1: Need – Easy home security for families Step 2: Research – Existing tools are too complex Step 3: Design – Simple app with alerts Step 4: Build – Prototype using Python and APIs Step 5: Test – Get family and friends to try it Step 6: Launch – Put it on the app store Step 7: Grow – Add more features and users
Encourage students to think about advanced topics and how they can apply them. Discuss the importance of ethics in security. Encourage students to explore startups and leadership. Use real-world examples to illustrate concepts. Encourage students to participate in bug bounty programs (ethically).
Support your child's interest in advanced topics. Discuss the ethical implications of technology. Encourage them to think about how they can innovate and lead. Help them explore startup ideas and mentorship opportunities.
Did you know that the first quantum computer was built in 1998? Today, companies like Google and IBM are building quantum computers that could change the world. This is why quantum-safe encryption is so important!
Orchestration Flow ------------------ [Scanner] → [Firewall] → [Alert System] → [Dashboard] → [Response]
ML Security Flow ---------------- Data → Train Model → Test Model → Deploy → Detect Threats
Blockchain Structure
--------------------
[Block 1] → [Block 2] → [Block 3] → [Block 4]
| | | |
V V V V
[Hash] [Hash] [Hash] [Hash]
| Feature | Traditional Security | ML Security |
|---|---|---|
| Detection | Rule-based | Pattern-based |
| Adaptability | Low | High |
| False Positives | High | Lower |
| Speed | Fast | Fast |
| Feature | Blockchain | Traditional Database |
|---|---|---|
| Immutability | High | Low |
| Transparency | High | Low |
| Security | High | Moderate |
| Cost | High | Low |
Congratulations! You have completed Module 8 and the entire "Fundamentals of Cyber Security Scripting" course. You now have a deep understanding of:
You are now equipped to take on the world of cyber security. Remember to always use your skills for good, keep learning, and never stop exploring. The digital world needs more heroes like you!
Match the term with its description:
| Term | Description |
|---|---|
| 1. Orchestration | A. New company |
| 2. Machine Learning | B. Connecting security tools |
| 3. Blockchain | C. Computers learning from data |
| 4. Startup | D. Secure, unchangeable records |
| 5. Quantum Computing | E. Fast computing that breaks encryption |
Answers: 1-B, 2-C, 3-D, 4-A, 5-E
Scenario 1: You are a security leader at a Nigerian bank. The bank is facing a quantum computing threat. Write a plan (pseudo-code) for how to prepare for this threat.
Scenario 2: You want to start a security startup in Nigeria. Write a business plan (pseudo-code) that outlines your product, target audience, and how you will launch it.
In groups of 3, design a security innovation using machine learning or blockchain. Create a presentation that explains the problem it solves, how it works, and the impact it could have. Present your idea to the class.
Write a Python script that demonstrates a simple machine learning concept (like a decision tree) for security. Use a sample dataset to train a model that detects phishing URLs.
Build a prototype of a security startup. Write a script or design a product that solves a security problem. Include a description, a basic prototype (code), and a go-to-market plan.
Write a script that performs OSINT on a domain. The script should gather information like WHOIS data, DNS records, and social media mentions. Print a report with your findings.
Write a script that simulates a bug bounty program. The script should:
All multiple-choice answers are indicated in the questions above (bold). Fill-in-the-blank answers: 1-Orchestration, 2-Machine learning, 3-Blockchain, 4-Quantum computing, 5-ethical dilemma, 6-startup, 7-Leadership, 8-Incident response at scale, 9-Bug bounties, 10-OSINT. True/False: 1-T, 2-F, 3-T, 4-F, 5-F, 6-F, 7-T, 8-F, 9-F, 10-F.
Congratulations on completing all eight modules! You have a solid foundation in cyber security scripting. The next course will be an advanced specialization where you will choose a path:
Keep your curiosity alive, keep practicing, and remember: the world needs more ethical cyber heroes. See you in the next adventure!
End of Module 8 · Fundamentals of Cyber Security Scripting
This concludes the eight-module foundation course. You are now a certified cyber hero! 🎉