20TD02U_ForAlle_Blooms_Side_48_20TD02S - itnett/FTD02H-N GitHub Wiki

For å dekke emnet "Cybersikkerhet" med full anvendelse av Blooms taksonomi, både programmatiske, logiske, og praktiske tilnærminger, kan vi strukturere læringen som følger:

• Logisk tilnærming: Forstå grunnleggende sikkerhetskonsepter som konfidensialitet, integritet og tilgjengelighet (CIA-triaden).
• Programmatisk tilnærming: Lag et Python-skript som simulerer en enkel kryptering og dekryptering for å demonstrere konfidensialitet.
• Praktisk tilnærming: Implementer et eksempel med AES-kryptering for å sikre data.

from Crypto.Cipher import AES
import base64

def pad(s):
    return s + (16 - len(s) % 16) * chr(16 - len(s) % 16)

def encrypt(message, key):
    cipher = AES.new(key.encode('utf-8'), AES.MODE_ECB)
    encrypted = cipher.encrypt(pad(message).encode('utf-8'))
    return base64.b64encode(encrypted).decode('utf-8')

def decrypt(encrypted_message, key):
    cipher = AES.new(key.encode('utf-8'), AES.MODE_ECB)
    decoded = base64.b64decode(encrypted_message)
    decrypted = cipher.decrypt(decoded).decode('utf-8')
    return decrypted.rstrip(chr(decrypted[-1]))

key = 'ThisIsASecretKey'
message = 'ConfidentialData'
encrypted = encrypt(message, key)
print(f"Encrypted: {encrypted}")
decrypted = decrypt(encrypted, key)
print(f"Decrypted: {decrypted}")

• Logisk tilnærming: Forstå hvordan sikkerhetsmekanismer beskytter data.
• Programmatisk tilnærming: Visualiser og sammenlign ulike krypteringsalgoritmer.
• Praktisk tilnærming: Bruk verktøy som Wireshark for å analysere forskjeller mellom kryptert og ukryptert nettverkstrafikk.

• Logisk tilnærming: Kjenne til vanlige typer trusler som malware, phishing, DDoS, etc.
• Programmatisk tilnærming: Lag en Python-basert trusseldatabase som kan hentes ut og vises som en oversikt.
• Praktisk tilnærming: Analyser reelle trusler ved hjelp av sikkerhetsovervåkingsverktøy som Snort eller Suricata.

threats = {
    'Malware': 'Software designed to disrupt, damage, or gain unauthorized access to a system.',
    'Phishing': 'A method of trying to gather personal information using deceptive e-mails and websites.',
    'DDoS': 'Distributed Denial of Service, a type of attack where multiple compromised systems are used to target a single system.'
}

def display_threats():
    for threat, description in threats.items():
        print(f"{threat}: {description}")

display_threats()

• Logisk tilnærming: Forstå hvordan disse truslene kan utnyttes.
• Programmatisk tilnærming: Simuler en DDoS-angrep i et kontrollerbart miljø ved hjelp av verktøy som LOIC.
• Praktisk tilnærming: Utfør en penetrasjonstest på et simulert nettverk ved hjelp av Metasploit.

• Logisk tilnærming: Lær om vanlige angrepsmetoder som SQL-injeksjon, XSS, etc.
• Programmatisk tilnærming: Implementer en enkel webapplikasjon med kjente sårbarheter for å forstå hvordan angrepene fungerer.
• Praktisk tilnærming: Bruk Burp Suite for å finne og utnytte sårbarheter i applikasjonen.

from flask import Flask, request, render_template_string

app = Flask(__name__)

@app.route('/', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        name = request.form['name']
        return render_template_string(f"<h1>Hello, {name}!</h1>")
    return '''
        <form method="post">
            Name: <input type="text" name="name"><br>
            <input type="submit" value="Submit">
        </form>
    '''

if __name__ == '__main__':
    app.run(debug=True)

• Logisk tilnærming: Forstå hvordan å forsvare seg mot disse angrepene ved å implementere grunnleggende sikkerhetstiltak.
• Programmatisk tilnærming: Legg til input-validering og sanitiseringsfunksjoner i applikasjonen for å hindre angrep.
• Praktisk tilnærming: Konfigurer en WAF (Web Application Firewall) for å beskytte mot slike trusler.

• Logisk tilnærming: Forstå begreper som risikoidentifikasjon, risikoanalyse, og risikovurdering.
• Programmatisk tilnærming: Lag et Python-skript for risikovurdering som rangerer trusler basert på sannsynlighet og innvirkning.
• Praktisk tilnærming: Utfør en risikovurdering på en eksisterende IT-infrastruktur ved hjelp av verktøy som NIST Risk Management Framework (RMF).

risks = {
    'Malware': {'Probability': 0.8, 'Impact': 0.9},
    'Phishing': {'Probability': 0.7, 'Impact': 0.5},
    'DDoS': {'Probability': 0.4, 'Impact': 0.7}
}

def calculate_risk(risks):
    for threat, metrics in risks.items():
        risk = metrics['Probability'] * metrics['Impact']
        print(f"Risk level for {threat}: {risk}")

calculate_risk(risks)

• Logisk tilnærming: Lær hvordan å utvikle tiltak for risikoredusering.
• Programmatisk tilnærming: Implementer automatiserte varslinger ved høy risiko ved hjelp av verktøy som Prometheus og Grafana.
• Praktisk tilnærming: Bruk risikostyringsverktøy som GRC (Governance, Risk, and Compliance) for å administrere risikoer over tid.

• Logisk tilnærming: Lær om viktige sikkerhetsrammeverk som ISO/IEC 27001, NIST Cybersecurity Framework, etc.
• Programmatisk tilnærming: Bygg et verktøy for å sammenligne kravene i forskjellige sikkerhetsrammeverk.
• Praktisk tilnærming: Implementer kontroller fra ISO 27001 i en organisasjon og evaluer samsvar.

frameworks = {
    'ISO 27001': ['Access Control', 'Asset Management', 'Cryptography'],
    'NIST CSF': ['Identify', 'Protect', 'Detect', 'Respond', 'Recover']
}

def compare_frameworks(frameworks):
    for framework, controls in frameworks.items():
        print(f"{framework}: {', '.join(controls)}")

compare_frameworks(frameworks)

• Logisk tilnærming: Forstå hvordan disse rammeverkene kan brukes til å sikre IT-infrastruktur.
• Programmatisk tilnærming: Lag et system som sporer samsvar med flere rammeverk.
• Praktisk tilnærming: Gjennomfør en revisjon av sikkerhetspraksis i forhold til ISO 27001-standarden.

• Logisk tilnærming: Forstå viktige lover som GDPR, CCPA, etc.
• Programmatisk tilnærming: Lag en database over lover og regler som kan søkes gjennom for å finne relevante krav.
• Praktisk tilnærming: Utfør en vurdering av en virksomhets samsvar med GDPR.

laws = {
    'GDPR': 'General Data Protection Regulation, applicable in the EU.',
    'CCPA': 'California Consumer Privacy Act, applicable in California, USA.'
}

def search_law(law_name):
    return laws.get(law_name, "Law not found.")

print(search_law('GDPR'))

Forståelse (Understanding)

• Logisk tilnærming: Forstå hvordan disse lovene påvirker IT-sikkerhetspraksis.
• Programmatisk tilnærming: Implementer automatiserte systemer for å sikre overholdelse av GDPR ved hjelp av løsninger som Data Loss Prevention (DLP).
• Praktisk tilnærming: Integrer løsninger som OneTrust eller TrustArc for å administrere personvern og samsvar.

• Ferdigheter:

  • Bruk verktøy som Splunk, ELK Stack for kontinuerlig overvåking av IT-trusselbildet.
  • Implementer og test grunnleggende mottiltak mot angrepsmetoder som buffer overflow og SQL-injeksjon ved bruk av OWASP Juice Shop.
  • Utfør risikovurderinger med verktøy som OCTAVE eller FAIR.
  • Bruk LexisNexis eller lignende verktøy for å finne og vurdere lover og regler.

• Generell kompetanse:

  • Delta i sikkerhetsprosjekter ved hjelp av Jira eller Trello for å spore oppgaver og fremdrift.
  • Bruk sikkerhetsstandarder som en sjekkliste for IT-løsninger i en organisasjon.
  • Diskuter og utveksle sikkerhetspraksis og trender i sikkerhetsfora eller arbeidsgrupper.

Denne fullstendige implementeringen av cybersikkerhetsemnet dekker alle aspekter av Blooms taksonomi, fra grunnleggende kunnskap til avansert anvendelse og syntese. Ved å følge denne strukturen vil studentene utvikle en omfattende forståelse og praktiske ferdigheter innen IT-sikkerhet, som de kan bruke til å identifisere trusler, implementere mottiltak, og sikre samsvar med relevante lover og rammeverk.

Denne veiledningen er optimalisert for studenter, utviklere og IT-fagfolk som ønsker en dyp forståelse og praktisk tilnærming til cybersikkerhet basert på Blooms taksonomi.