20TD02S_Informasjonssikkerhet_K04 - itnett/FTD02H-N GitHub Wiki

Kapittel 4: Kryptografi

Innholdsfortegnelse

  1. Hva er kryptografi?
  2. Symmetrisk Kryptografi
  3. Asymmetrisk Kryptografi
  4. Digital Signatur
  5. Hashfunksjoner
  6. Meldingsautentisering
  7. Postkvantekrypto
  8. Oppgaver
  9. Videre Læring og Kilder

Kapittel 4: Kryptografi

Innholdsfortegnelse

  1. Hva er kryptografi?
  2. Symmetrisk Kryptografi
  3. Asymmetrisk Kryptografi
  4. Digital Signatur
  5. Hashfunksjoner
  6. Meldingsautentisering
  7. Postkvantekrypto

1. Hva er kryptografi?

Kryptografi er vitenskapen om å skjule betydningen av en melding ved å konvertere klartekst til chiffertekst. Kryptografi kan støtte flere sikkerhetsmål som konfidensialitet, dataintegritet, autentisering og ikke-benektelse.

Kryptanalyse er vitenskapen om å bryte kryptografi.

Kryptologi dekker både kryptografi og kryptanalyse.

Ressurser:

2. Symmetrisk Kryptografi

Symmetrisk kryptografi bruker samme hemmelige nøkkel for både kryptering og dekryptering. Noen kjente algoritmer inkluderer DES, AES og RC4.

Blokkchiffer

Blokkchiffer krypterer data i faste blokker (typisk 128 bits). Vanlige operasjonsmoduser inkluderer:

  • ECB (Electronic Code Book): Krypterer hver blokk individuelt. Sårbar for mønstergjenkjenning.
  • CBC (Cipher Block Chaining): Hver blokk kombineres med forrige blokk ved hjelp av XOR før kryptering. Sikkerere enn ECB.
  • CTR (Counter Mode): Bruker en teller som kombineres med data ved hjelp av XOR. Gir sikkerhet selv for like blokker.

Strømchiffer

Strømchiffer krypterer data som en kontinuerlig strøm av bits eller bytes. Eksempel: RC4.

Ressurser:

3. Asymmetrisk Kryptografi

Asymmetrisk kryptografi bruker et nøkkelpar: en offentlig nøkkel for kryptering og en privat nøkkel for dekryptering. Kjente algoritmer inkluderer RSA og Elliptiske Kurver.

Diffie-Hellman nøkkelutveksling

Diffie-Hellman-algoritmen lar to parter opprette en felles hemmelig nøkkel over en usikker kanal uten å ha møtt hverandre før.

Hybrid Kryptering

Kombinerer både symmetriske og asymmetriske metoder for å dra nytte av hastigheten til symmetrisk kryptering og sikkerheten til asymmetrisk kryptering.

Ressurser:

4. Digital Signatur

En digital signatur er en kryptografisk metode som brukes til å validere autentisiteten og integriteten til en melding, programvare eller digitalt dokument.

Prosess:

  1. Alice hasher meldingen M for å lage en hash-verdi.
  2. Alice krypterer hash-verdien med sin private nøkkel for å lage signaturen S(M).
  3. Alice sender meldingen M og signaturen S(M) til Bob.
  4. Bob dekrypterer signaturen S(M) med Alices offentlige nøkkel og sammenligner hash-verdien med hashen av meldingen M.

Ressurser:

5. Hashfunksjoner

Hashfunksjoner brukes til å verifisere integriteten til data ved å konvertere data til en fast størrelse hash-verdi. Kjente hashfunksjoner inkluderer MD5, SHA-1, og SHA-2.

Krav til Hashfunksjoner:

  1. Lett å beregne.
  2. Komprimering av vilkårlig stor input til fast størrelse.
  3. Enveis: Umulig å finne original input fra hash-verdi.
  4. Kollisjonsresistens: Umulig å finne to forskjellige inputs med samme hash-verdi.

Ressurser:

6. Meldingsautentisering

Meldingsautentiseringskode (MAC) brukes til å sikre integritet og autentisitet av en melding. En MAC-verdi beregnes ved å kombinere meldingen med en hemmelig nøkkel ved hjelp av en hash-funksjon.

Prosess:

  1. Alice beregner MAC(M) ved å hashe meldingen M med en hemmelig nøkkel K.
  2. Alice sender meldingen M og MAC(M) til Bob.
  3. Bob beregner MAC(M) med samme nøkkel K og sammenligner med mottatt MAC-verdi.

Ressurser:

7. Postkvantekrypto

Postkvantekrypto refererer til kryptografiske algoritmer som er sikre mot angrep fra kvantedatamaskiner. NIST har valgt fire PQC-algoritmer for standardisering i 2023/2024.

Ressurser:

Oppgaver

Oppgave 1: Cæsar-chiffer

a. Matematisk uttrykk for antall forskjellige nøkler: $$[ N = 30! ] Antall forskjellige nøkler = ( 30! ) [ 30! = 2.652528598 \times 10^{32} ]$$

b. Nøkkelstørrelse for 30 tegn uttrykt i antall bits: $$[ \text{Nøkkelstørrelse} = \log_2(30!) \approx 108.24 \text{ bits} ]$$

c. Nøkkelstørrelse for 34 tegn: $$[ \text{Nøkkelstørrelse} = \log_2(34!) \approx 136.1 \text{ bits} ]$$ Denne nøkkelstørrelsen er tilstrekkelig for å motstå uttømmende søk.

d. Kan algoritmen motstå statistisk kryptanalyse? Nei, omstokking alene gjør ikke algoritmen sterk nok til å skjule statistiske ujevnheter.

e. Kryptanalysere en chiffertekst:

  • Analyser bokstavfrekvensene i chifferteksten.
  • Sammenlign med kjente frekvenser for å identifisere mest sannsynlige bokstavkorrespondanser.

Oppgave 2: Digital signatur

a. Trinnene Alice må følge for å sende M:

  1. Alice hasher meldingen M.
  2. Alice krypterer hash-verdien med sin private nøkkel.
  3. Alice sender M og signaturen til Bob.

b. Trinnene Bob må følge for å validere M:

  1. Bob mottar M og signaturen.
  2. Bob dekrypterer signaturen med Alices offentlige nøkkel.
  3. Bob hasher M og sammenligner med dekryptert hash-verdi.

c. Hvordan digital signatur beviser autentisitet:

  • Digital signatur sikrer at meldingen er autentisk og ikke har blitt endret. Denne egenskapen kalles ikke-benektelse.

d. Grunner for å nekte signert melding:

  • Alice kan påstå at hennes private nøkkel ble stjålet. Dette utfordrer begrepet "ubenektelighet".

e. Semantisk tolkning av "digitalt signert melding":

  • I) Alice er enig i innholdet.
  • II) Alice sendte meldingen uten nødvendigvis å være enig.

Oppgave 3: Strømchiffer

  • En angriper kan endre overføringsbeløpet ved å manipulere chifferteksten direkte, gitt kjennskap til meldingsformatet.

Oppgave 4: Fremoverhemmelighold

a. Hva er fremoverhemmelighold:

  • Sikrer at tidligere kommunikasjoner forblir

sikre selv om langsiktige nøkler kompromitteres.

b. Gir fremoverhemmelighold:

  • Nei, fordi hvis Bobs private nøkkel kompromitteres, kan tidligere øktnøkler dekrypteres.

c. Typisk metode for å oppnå fremoverhemmelighold:

  • Bruk av Diffie-Hellman nøkkelutveksling. Eksempel: TLS 1.3.

Oppgave 5: Diffie-Hellman

a. Trinnene i Diffie-Hellman:

  1. Alice og Bob blir enige om en primtall $( p )$ og generator $( g )$.
  2. Alice velger en hemmelig nøkkel ( a ) og sender ( A = g^a \mod p ) til Bob.
  3. Bob velger en hemmelig nøkkel $( b )$ og sender $( B = g^b \mod p )$ til Alice.
  4. Alice beregner $( K = B^a \mod p )$.
  5. Bob beregner $( K = A^b \mod p )$.

b. Hvorfor Diffie-Hellman ikke gir autentisering:

  • Algoritmen autentiserer ikke partene. Løsning: Bruk digitale signaturer i tillegg.

Oppgave 6: Symmetrisk kryptering

a. Trinnene Alice må følge for å kryptere M:

  1. Alice bruker nøkkelen K til å kryptere M ved hjelp av funksjonen E.
  2. Alice sender den krypterte meldingen C til Bob.

b. Trinnene Bob må følge for å dekryptere C:

  1. Bob mottar C.
  2. Bob bruker nøkkelen K til å dekryptere C ved hjelp av funksjonen D.

Oppgave 7: Hashfunksjoner

a. Fire fundamentale krav til hash-funksjoner:

  1. Lett å beregne.
  2. Komprimering til fast størrelse.
  3. Enveis.
  4. Kollisjonsresistens.

b. Forskjellen mellom kollisjonsresistens:

  • Svak kollisjonsresistens: Umulig å finne et annet datasett som gir samme hash.
  • Sterk kollisjonsresistens: Umulig å finne to forskjellige datasett som gir samme hash.

c. SHA-2 demo webside:

Oppgave 8: Meldingsautentisering

a. Trinnene Alice må følge:

  1. Alice beregner MAC(M) ved å hashe meldingen M med nøkkelen K.
  2. Alice sender M og MAC(M) til Bob.

b. Trinnene Bob må følge:

  1. Bob mottar M og MAC(M).
  2. Bob beregner MAC(M) med samme nøkkel K og sammenligner.

c. Hvordan MAC beviser autentisitet:

  • MAC sikrer meldingen, men Bob kan ikke bevise autentisitet for en tredjepart.

Oppgave 9: Bruk av kryptografi

a. Datatilstander kryptografi kan beskytte:

  • Lagring, overføring, prosessering. Beskyttelse av data under prosessering kan gjøres med kryptografiske teknikker som homomorfisk kryptering.

b. Sikkerhetsmål støttet av kryptografi:

  • Konfidensialitet, integritet, autentisering, ikke-benektelse.

Oppgave 10: Postkvantekrypto

a. Fire PQC-algoritmer valgt av NIST:

  • Kyber, NTRU, SABER, Crystals-Dilithium.

b. Nye typer PQC-algoritmer NIST ønsker:

  • Algoritmer for både nøkkelutveksling og digital signatur som er sikre mot kvanteangrep.

Videre Læring og Kilder

Offisielle Rapporter:

  1. ENISA Reports

  2. Nasjonal Sikkerhetsmyndighet (NSM)

Akademiske Artikler og Bøker:

  1. Jøsang, A. (2023). Informasjonssikkerhet: Teori og praksis. Universitetsforlaget.
  2. Schneier, B. (2015). Data and Goliath: The Hidden Battles to Collect Your Data and Control Your World. W.W. Norton & Company.

Nettressurser:

  1. NIST Cybersecurity Framework - NIST
  2. OWASP (Open Web Application Security Project) - OWASP
  3. SANS Institute - SANS

Dette gir en omfattende dekning av kryptografi og relaterte emner, støttet av ressurser og eksempler for videre studier og forståelse.

For å lage et omfattende og tydelig script på trinket.io som dekker de viktigste temaene innen kryptografi, skal vi lage flere mindre skript som dekker hvert enkelt tema, og et hovedskript som setter alt i system. Hvert skript vil være godt kommentert på både norsk og engelsk for å sikre forståelse.

1. Symmetrisk Kryptering (AES)

# Import the necessary modules
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes

# Norsk: Funksjon for å kryptere meldinger med AES
# English: Function to encrypt messages using AES
def encrypt_aes(key, data):
    # Create a cipher object using the random key
    cipher = AES.new(key, AES.MODE_EAX)
    nonce = cipher.nonce
    # Encrypt the data
    ciphertext, tag = cipher.encrypt_and_digest(data)
    return nonce, ciphertext, tag

# Norsk: Funksjon for å dekryptere meldinger med AES
# English: Function to decrypt messages using AES
def decrypt_aes(key, nonce, ciphertext, tag):
    # Create a cipher object using the random key and nonce
    cipher = AES.new(key, AES.MODE_EAX, nonce=nonce)
    # Decrypt the data
    data = cipher.decrypt_and_verify(ciphertext, tag)
    return data

# Norsk: Generer en tilfeldig nøkkel
# English: Generate a random key
key = get_random_bytes(16) # 128 bits key
data = b'Hello, this is a test message!'

# Norsk: Krypter meldingen
# English: Encrypt the message
nonce, ciphertext, tag = encrypt_aes(key, data)
print(f"Kryptert tekst: {ciphertext}")

# Norsk: Dekrypter meldingen
# English: Decrypt the message
decrypted_data = decrypt_aes(key, nonce, ciphertext, tag)
print(f"Dekryptert tekst: {decrypted_data.decode()}")

2. Asymmetrisk Kryptering (RSA)

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP

# Norsk: Generer RSA-nøkkelpar
# English: Generate RSA key pair
key = RSA.generate(2048)
private_key = key.export_key()
public_key = key.publickey().export_key()

# Norsk: Lagre nøklene til filer
# English: Save the keys to files
with open("private.pem", "wb") as f:
    f.write(private_key)
with open("public.pem", "wb") as f:
    f.write(public_key)

# Norsk: Last inn de offentlige og private nøklene
# English: Load the public and private keys
with open("public.pem", "rb") as f:
    public_key = RSA.import_key(f.read())
with open("private.pem", "rb") as f:
    private_key = RSA.import_key(f.read())

# Norsk: Funksjon for å kryptere meldinger med RSA
# English: Function to encrypt messages using RSA
def encrypt_rsa(public_key, data):
    cipher = PKCS1_OAEP.new(public_key)
    ciphertext = cipher.encrypt(data)
    return ciphertext

# Norsk: Funksjon for å dekryptere meldinger med RSA
# English: Function to decrypt messages using RSA
def decrypt_rsa(private_key, ciphertext):
    cipher = PKCS1_OAEP.new(private_key)
    data = cipher.decrypt(ciphertext)
    return data

# Norsk: Krypter og dekrypter meldingen
# English: Encrypt and decrypt the message
data = b'Hello, this is a test message!'
ciphertext = encrypt_rsa(public_key, data)
print(f"Kryptert tekst: {ciphertext}")

decrypted_data = decrypt_rsa(private_key, ciphertext)
print(f"Dekryptert tekst: {decrypted_data.decode()}")

3. Hashfunksjoner (SHA-256)

import hashlib

# Norsk: Funksjon for å beregne SHA-256 hash av data
# English: Function to compute SHA-256 hash of data
def hash_sha256(data):
    sha256 = hashlib.sha256()
    sha256.update(data)
    return sha256.hexdigest()

# Norsk: Data som skal hashes
# English: Data to be hashed
data = b'Hello, this is a test message!'
hash_value = hash_sha256(data)
print(f"SHA-256 hash: {hash_value}")

4. Digital Signatur (RSA)

from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256

# Norsk: Funksjon for å signere data med RSA
# English: Function to sign data using RSA
def sign_rsa(private_key, data):
    h = SHA256.new(data)
    signature = pkcs1_15.new(private_key).sign(h)
    return signature

# Norsk: Funksjon for å verifisere signatur med RSA
# English: Function to verify signature using RSA
def verify_rsa(public_key, data, signature):
    h = SHA256.new(data)
    try:
        pkcs1_15.new(public_key).verify(h, signature)
        return True
    except (ValueError, TypeError):
        return False

# Norsk: Signer og verifiser meldingen
# English: Sign and verify the message
data = b'Hello, this is a test message!'
signature = sign_rsa(private_key, data)
print(f"Signatur: {signature}")

is_valid = verify_rsa(public_key, data, signature)
print(f"Signatur gyldig: {is_valid}")

5. Hovedskript som setter alt i system

# Import the necessary modules
from Crypto.Cipher import AES, PKCS1_OAEP
from Crypto.PublicKey import RSA
from Crypto.Random import get_random_bytes
from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256
import hashlib

# Norsk: Generer RSA-nøkkelpar for asymmetrisk kryptering og digital signatur
# English: Generate RSA key pair for asymmetric encryption and digital signature
key = RSA.generate(2048)
private_key = key.export_key()
public_key = key.publickey().export_key()
private_key = RSA.import_key(private_key)
public_key = RSA.import_key(public_key)

# Norsk: Generer en tilfeldig nøkkel for symmetrisk kryptering
# English: Generate a random key for symmetric encryption
aes_key = get_random_bytes(16)

# Data to be encrypted, hashed, and signed
data = b'Hello, this is a comprehensive test message!'

# 1. Symmetrisk Kryptering (AES)
def encrypt_aes(key, data):
    cipher = AES.new(key, AES.MODE_EAX)
    nonce = cipher.nonce
    ciphertext, tag = cipher.encrypt_and_digest(data)
    return nonce, ciphertext, tag

def decrypt_aes(key, nonce, ciphertext, tag):
    cipher = AES.new(key, AES.MODE_EAX, nonce=nonce)
    data = cipher.decrypt_and_verify(ciphertext, tag)
    return data

nonce, ciphertext_aes, tag = encrypt_aes(aes_key, data)
print(f"Symmetrisk Kryptert tekst: {ciphertext_aes}")
decrypted_data_aes = decrypt_aes(aes_key, nonce, ciphertext_aes, tag)
print(f"Symmetrisk Dekryptert tekst: {decrypted_data_aes.decode()}")

# 2. Asymmetrisk Kryptering (RSA)
def encrypt_rsa(public_key, data):
    cipher = PKCS1_OAEP.new(public_key)
    ciphertext = cipher.encrypt(data)
    return ciphertext

def decrypt_rsa(private_key, ciphertext):
    cipher = PKCS1_OAEP.new(private_key)
    data = cipher.decrypt(ciphertext)
    return data

ciphertext_rsa = encrypt_rsa(public_key, data)
print(f"Asymmetrisk Kryptert tekst: {ciphertext_rsa}")
decrypted_data_rsa = decrypt_rsa(private_key, ciphertext_rsa)
print(f"Asymmetrisk Dekryptert tekst: {decrypted_data_rsa.decode()}")

# 3. Hashfunksjoner (SHA-256)
def hash_sha256(data):
    sha256 = hashlib.sha256()
    sha256.update(data)
    return sha256.hexdigest()

hash_value = hash_sha256(data)
print(f"SHA-256 hash: {hash_value}")

# 4. Digital Signatur (RSA)
def sign_rsa(private_key, data):
    h = SHA256.new(data)
    signature = pkcs1_15.new(private_key).sign(h)
    return signature

def verify_rsa(public_key, data, signature):
    h = SHA256.new(data)
    try:
        pkcs1_15.new(public_key).verify(h, signature)
        return True
    except (ValueError, TypeError):
        return False

signature = sign_rsa(private_key, data)
print(f"Signatur: {signature}")
is_valid = verify_rsa(public_key, data, signature)
print(f"Signatur gyldig: {is_valid}")

Disse skriptene dekker grunnleggende kryptografiske konsepter, inkludert symmetrisk kryptering, asymmetrisk kryptering, hashfunksjoner, og digitale signaturer. Hvert skript er kommentert på både norsk og engelsk for å sikre tydelig forståelse av både konseptene og koden. Du kan

enkelt kjøre disse skriptene på trinket.io ved å kopiere og lime dem inn.

GeoGebra er et kraftig verktøy for å visualisere matematikk og kan brukes til å demonstrere noen av de matematiske prinsippene bak kryptografi. Her er en trinnvis guide til hvordan du kan bruke GeoGebra til å illustrere noen av de viktigste konseptene og oppgavene fra kryptografi:

1. Cæsar-Chiffer

Cæsar-chifferet er en enkel substitusjonskryptering hvor hver bokstav i klarteksten erstattes med en bokstav et fast antall plasser unna i alfabetet.

Trinn for GeoGebra:

  1. Åpne GeoGebra.
  2. Velg "Algebra" fra visningsalternativene.
  3. Lag en glider k som representerer nøkkelen (forskyvningen), for eksempel mellom 0 og 25.
  4. Bruk funksjonen Mod til å beregne forskyvningen av hver bokstav.
// Lag en liste over alfabetet
Alfabet = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"}

// Definer en klartekst
Klartekst = {"H", "E", "L", "L", "O"}

// Krypter hver bokstav med forskyvning k
KryptertTekst = If(Klartekst, Element(Alfabet, Mod(IndexOf(Alfabet, Klartekst) + k - 1, 26) + 1))

2. Diffie-Hellman nøkkelutveksling

Diffie-Hellman nøkkelutveksling er en metode for to parter å dele en felles hemmelig nøkkel over en usikker kanal.

Trinn for GeoGebra:

  1. Åpne GeoGebra.
  2. Bruk "Algebra" for å definere parametrene (primtall p og generator g).
  3. Lag glidere for de hemmelige nøklene a og b.
// Definer et primtall p og en generator g
p = 23
g = 5

// Definer hemmelige nøkler a og b
a = 6
b = 15

// Beregn offentlige verdier A og B
A = Mod(g^a, p)
B = Mod(g^b, p)

// Beregn den delte hemmelige nøkkelen K
K_a = Mod(B^a, p)
K_b = Mod(A^b, p)

// Kontroller at K_a og K_b er like
K_a == K_b

3. RSA Algoritme

RSA er en asymmetrisk kryptografisk algoritme som bruker et nøkkelpar (en offentlig og en privat nøkkel) for kryptering og dekryptering.

Trinn for GeoGebra:

  1. Åpne GeoGebra.
  2. Definer to primtall p og q.
  3. Beregn produktet n og Eulers totientfunksjon φ(n).
// Definer to primtall p og q
p = 61
q = 53

// Beregn n og φ(n)
n = p * q
φ_n = (p - 1) * (q - 1)

// Velg en eksponent e som er relativt prim til φ(n)
e = 17

// Beregn den private eksponenten d
d = ModInverse(e, φ_n)

// Definer en melding m (må være mindre enn n)
m = 65

// Krypter meldingen
c = Mod(m^e, n)

// Dekrypter meldingen
m_decrypted = Mod(c^d, n)

// Kontroller at m_decrypted er lik m
m == m_decrypted

4. Hashfunksjoner (SHA-256)

Mens SHA-256 er for kompleks for full visualisering i GeoGebra, kan du illustrere grunnleggende hashing-konsepter ved å lage en enkel hashfunksjon.

Trinn for GeoGebra:

  1. Åpne GeoGebra.
  2. Definer en enkel hashfunksjon som tar en numerisk verdi og returnerer en "hash".
// Enkel hashfunksjon
HashFunksjon(x) = Mod(x^2 + 3*x + 7, 100)

// Hash en verdi
x = 123
HashVerdi = HashFunksjon(x)

Disse eksemplene gir en start på hvordan du kan bruke GeoGebra til å visualisere og demonstrere matematikken bak kryptografi. Hver del illustrerer hvordan du kan bruke matematiske funksjoner og verktøy i GeoGebra for å forstå og forklare kryptografiske konsepter.