🛡️ Cybersecurity Fundamentals Learning Module

🛡️ Cybersecurity Fundamentals Learning Module#

📘 What Is Cybersecurity?#

Cybersecurity is the practice of protecting systems, networks, and data from digital attacks, unauthorized access, and damage. It ensures:

🔒 Confidentiality: Only authorized users can access data.
🧩 Integrity: Data remains accurate and unaltered.
📶 Availability: Systems and data are accessible when needed.

Cybersecurity spans personal devices, enterprise systems, cloud platforms, and critical infrastructure.

Learn more from Kaspersky

🧱 Core Components of Cybersecurity#

Component	Description
Network Security	Protects data during transmission across networks using firewalls, VPNs, IDS
Application Security	Secures software from vulnerabilities like SQL injection or XSS
Information Security	Safeguards sensitive data using encryption, access control, and DLP
Operational Security	Manages policies, user behavior, and physical security
Endpoint Security	Protects devices like laptops, phones, and IoT nodes
Cloud Security	Secures cloud-hosted data and services (e.g., AWS, Azure)
Identity & Access Management (IAM)	Controls user access and authentication
Incident Response	Detects, contains, and recovers from cyberattacks

Source: Digitdefence

🔐 Common Cybersecurity Algorithms#

Algorithm	Type	Purpose
AES	Symmetric	Fast, secure encryption for data at rest
RSA	Asymmetric	Public/private key encryption for secure exchange
SHA-256	Hashing	Generates fixed-length hash for integrity
Diffie-Hellman	Key Exchange	Securely shares keys over public channels
Elliptic Curve Cryptography (ECC)	Asymmetric	Efficient encryption with smaller keys
bcrypt / scrypt / Argon2	Hashing	Password hashing with resistance to brute-force

Source: GeeksforGeeks

🔄 Cybersecurity Lifecycle Steps#

Stage	Description
Identify	Catalog assets, assess risks, and define policies
Protect	Implement safeguards (firewalls, access control, training)
Detect	Monitor systems for breaches and anomalies
Respond	Contain and mitigate the impact of incidents
Recover	Restore systems and update defenses post-incident

Source: CimTrak

👨‍💼 Cybersecurity Roles & Responsibilities#

Role	Key Responsibilities
Security Analyst	Monitor threats, analyze logs, respond to incidents
Security Engineer	Design and implement secure systems and firewalls
Penetration Tester	Simulate attacks to find vulnerabilities
Security Consultant	Advise organizations on improving security posture
IAM Specialist	Manage user identities and access controls
Forensics Analyst	Investigate breaches and recover digital evidence
Security Manager	Oversee teams, policies, and compliance

Source: CyberSN

🧠 Skills Needed for Cybersecurity Success#

Skill Area	Description
Networking & OS	Deep understanding of TCP/IP, Linux, Windows, and system internals
Scripting & Automation	Python, Bash, PowerShell for automating tasks and analysis
Intrusion Detection	Use of SIEM, IDS/IPS tools to monitor and detect threats
Risk Management	Assess vulnerabilities and prioritize mitigation strategies
Cloud Security	Secure AWS, Azure, GCP environments and APIs
Cryptography	Understand encryption, hashing, and secure key management
Incident Response	Contain, analyze, and recover from security breaches
Soft Skills	Communication, problem-solving, adaptability

Source: Coursera

Would you like this scaffolded into an interactive notebook with dropdowns, quizzes, or live code modules for encryption and intrusion detection?

#pip install pycryptodome

## algorithm Explorer

# 📦 Required Libraries
from Crypto.Cipher import AES, PKCS1_OAEP
from Crypto.PublicKey import RSA
from Crypto.Random import get_random_bytes
import hashlib
import bcrypt
import os
from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
from argon2 import PasswordHasher
import ipywidgets as widgets
from IPython.display import display, clear_output, Markdown

# 🧠 Algorithm Metadata
metadata = {
    "AES (Symmetric Encryption)": {
        "input": "Plaintext message",
        "output": "Encrypted ciphertext using a random 128-bit key",
        "interpretation": "Used for fast, secure data transmission"
    },
    "RSA (Asymmetric Encryption)": {
        "input": "Plaintext message",
        "output": "Encrypted data using public key",
        "interpretation": "Ideal for secure key exchange"
    },
    "SHA-256 (Hashing)": {
        "input": "Password or message",
        "output": "Fixed-length 256-bit hash",
        "interpretation": "Used for verifying data integrity"
    },
    "Diffie-Hellman (Key Exchange)": {
        "input": "Private keys and public parameters",
        "output": "Shared secret",
        "interpretation": "Secure key exchange over insecure channels"
    },
    "ECC (Elliptic Curve Cryptography)": {
        "input": "Conceptual only",
        "output": "Explanation",
        "interpretation": "Strong security with smaller key sizes"
    },
    "bcrypt (Password Hashing)": {
        "input": "Password",
        "output": "Hashed password with salt",
        "interpretation": "Secure password storage"
    },
    "scrypt (Password Hashing)": {
        "input": "Password",
        "output": "Derived key",
        "interpretation": "Memory-hard password hashing"
    },
    "Argon2 (Password Hashing)": {
        "input": "Password",
        "output": "Hashed password",
        "interpretation": "Highly secure and configurable"
    }
}

# 🧪 Algorithm Demos with Custom Input
def aes_demo(message):
    key = get_random_bytes(16)
    cipher = AES.new(key, AES.MODE_EAX)
    ciphertext, tag = cipher.encrypt_and_digest(message.encode())
    return ciphertext

def rsa_demo(message):
    key = RSA.generate(2048)
    cipher = PKCS1_OAEP.new(key)
    encrypted = cipher.encrypt(message.encode())
    return encrypted

def sha_demo(message):
    hash_obj = hashlib.sha256(message.encode())
    return hash_obj.hexdigest()

def diffie_hellman_demo(_):
    p, g, a, b = 23, 5, 6, 15
    A = pow(g, a, p)
    B = pow(g, b, p)
    shared_secret = pow(B, a, p)
    return shared_secret

def ecc_demo(_):
    return "ECC typically uses curves like secp256k1 for secure key exchange and signatures."

def bcrypt_demo(message):
    hashed = bcrypt.hashpw(message.encode(), bcrypt.gensalt())
    return hashed

def scrypt_demo(message):
    salt = os.urandom(16)
    kdf = Scrypt(salt=salt, length=32, n=2**14, r=8, p=1)
    key = kdf.derive(message.encode())
    return key

def argon2_demo(message):
    ph = PasswordHasher()
    hash = ph.hash(message)
    return hash

### 🧠 Interactive Widgets
algorithms = {
    "AES (Symmetric Encryption)": aes_demo,
    "RSA (Asymmetric Encryption)": rsa_demo,
    "SHA-256 (Hashing)": sha_demo,
    "Diffie-Hellman (Key Exchange)": diffie_hellman_demo,
    "ECC (Elliptic Curve Cryptography)": ecc_demo,
    "bcrypt (Password Hashing)": bcrypt_demo,
    "scrypt (Password Hashing)": scrypt_demo,
    "Argon2 (Password Hashing)": argon2_demo
}

dropdown = widgets.Dropdown(
    options=list(algorithms.keys()),
    description="🔐 Select Algorithm:",
    style={'description_width': 'initial'},
    layout=widgets.Layout(width='600px')
)

text_input = widgets.Text(
    value='HelloWorld123',
    description='📥 Input:',
    style={'description_width': 'initial'},
    layout=widgets.Layout(width='600px')
)

output = widgets.Output()

def run_demo(change=None):
    output.clear_output()
    algo_name = dropdown.value
    demo_func = algorithms[algo_name]
    user_input = text_input.value
    with output:
        display(Markdown(f"### 📘 Description\n{metadata[algo_name]['interpretation']}"))
        display(Markdown(f"**📥 Input:** {user_input}"))
        result = demo_func(user_input)
        display(Markdown(f"**📤 Output:**\n```\n{result}\n```"))
        display(Markdown(f"**📊 Interpretation:** {metadata[algo_name]['interpretation']}"))

dropdown.observe(run_demo, names='value')
text_input.observe(run_demo, names='value')

display(dropdown, text_input, output)

import pandas as pd

comparison_data = {
    "Algorithm": ["AES", "RSA", "SHA-256", "Diffie-Hellman", "ECC", "bcrypt", "scrypt", "Argon2"],
    "Type": ["Symmetric", "Asymmetric", "Hash", "Key Exchange", "Asymmetric", "Hash", "Hash", "Hash"],
    "Speed": ["Fast", "Slower", "Fast", "Medium", "Fast", "Slow", "Slow", "Slow"],
    "Security": ["Strong", "Strong", "Strong", "Strong", "Very Strong", "Strong", "Very Strong", "Very Strong"],
    "Use Case": ["Data encryption", "Key exchange", "Integrity", "Secure key sharing", "Secure exchange/signature", "Password storage", "Password storage", "Password storage"]
}

df = pd.DataFrame(comparison_data)
display(df)

	Algorithm	Type	Speed	Security	Use Case
0	AES	Symmetric	Fast	Strong	Data encryption
1	RSA	Asymmetric	Slower	Strong	Key exchange
2	SHA-256	Hash	Fast	Strong	Integrity
3	Diffie-Hellman	Key Exchange	Medium	Strong	Secure key sharing
4	ECC	Asymmetric	Fast	Very Strong	Secure exchange/signature
5	bcrypt	Hash	Slow	Strong	Password storage
6	scrypt	Hash	Slow	Very Strong	Password storage
7	Argon2	Hash	Slow	Very Strong	Password storage