Computernetwerken 2

2009 januari examen

  1. De 3 eerste berichten van een TCP-verbinding.
  2. Leg uit:
    1. BGP
    2. Tunnel en transport mode bij IPSec
    3. Tier 1, 2 en 3
    4. Internet Exchange
  3. Leg uit: Probleem bij firewall bij FTP
  4. jitter bij voip uitleggen
  5. je krijgt een ip6-adres waar nullen of andere getallen weg zijn, en jij moet het omzetten naar het normale ip6-adres
    vb: ABCD:1234::4567:48 = ABCD:1234:0000:0000:0000:0000:4567:0048
  6. vragen over kerberos (kan ze niet zo meer zeggen maar er was een vraag over)
  7. wat is onweerlegbaarheid
  8. hoe kan je dit doen met RSA
  9. waarom kan dat niet met met symetrishe encrypty
  10. Invulvraag over subnetten + Omgekeerd wildcardmask.

2010 augustus examen

Theorie

  1. Verdeel 10.34.0.0/16 in subnetten voor minstens 600 computers
  2. Gegeven: TCP logs, je moet kunnen uitleggen wat er gebeurd
  3. Leg Kerberos in schemavorm uit. Wat is een ticket? Waarom kan deze niet nagemaakt worden?
  4. Wat is PGP? Hoe zorgt dit voor integrieit en authentificatie?
  5. Wat is onweerlegbaarheid?
  6. Waar of niet waar?
    Een isp moet betalen voor zijn internetverbinding
    IP-telefonie gaat via UDP
    Bij https wordt alles met het certificaat van de server versleutelt

 

Praktijk

  1. Schrijf een oneliner die in usr/share/dict/dutch alle woorden zoekt die zonder letter en zonder cijfer beginnen (dus é à - mogen wel), geef daar de 8ste van.
  2. Schrijf een oneliner die /ldapusers/kubeh/geheim/geheim.txt decodeerd met cypher -aes128 en dit in het bestand ontcijferd.txt in je homedirectory zet.
  3. In de map van Kubeh staan er 5 gecrypteerde tekstbestanden, 1 ervan kan je ontcijferen met de publieke sleutel kubeh.pub, welke? Geef de (meerdere) commando's die je gebruikte.
  4. Gebruik je kennis over het HTTP protocol om met netcat, grep en echo de grootte te weten van de afbeelding hallo.png die op onze webserver staat met poort 8000 (debbie.nwlab.khleuven.be)

2010 januari examen

Praktijk

Alles moet in 1 commando!

  1. Maak de bestandsstructuur ~/dir1/dir2/dir3/dir4/ als dir1 nog niet bestaat (in 1 commando!).

         if [ ! -d dir1 ];then mkdir -p dir1/dir2/dir3/dir4; fi

  1. Decrypteer een file met een AES-algoritme en een gegeven paswoord en schrijf de uitvoer naar een file.
  2. verplaats 10 '.jpg'-bestanden van een gegeven map naar je home dir en verander de extensies van jpg naar avi (in 1 commando!).

         mv /home/ldapusers/512345/Gegevenmap/*.jpg .. | rename -f 's/\.jpg$/.avi/' /home/ldapusers/512345/*.jpg

  1. haal uit een woordenlijst alle woorden waar een x EN een y in voorkomen, geef enkel het 10de resultaat weer.
  2. geef alle 10 letterwoorden met 10 unieke letters weer. (TIP: back referencing)

 

Theorie

  1. Subnetten verdelen en in CIDR vorm kunnen opschrijven
    1. 10.20.0.0 verdelen in subnetten die elk minstens 365 hosts bevatten
  2. Gegeven: TCPdump fragment. IP-adres van de DNS server zoeken; enkele stappen uitleggen en de waarde van de volgende ACK-bit berekenen. (goed kijken naar de vorige lijen --> Waarde kan je zo aflezen)
  3. Beschrijf in schemavorm hoe Kerberos authenticatie werkt. Is deze bestendig tegen een replay aanval? Waarom wel/niet?
  4. Wat is een digitale handtekening? Hoe zorgt dit voor integriteit en authenticiteit. 
  5. Wat is onweerlegbaarheid? Hoe zorgt het voor authenticatie en integriteit?
  6. IPv6 adres voluit schrijven vb: A5C2:CBE5:C::ABB5:ABBC
  7. Juist of fout? Licht toe met 1 zin:
    1. NAT werkt niet met IPsec (AH) in tunnelmode , met esp wel 
    2. DMZ is enkel beveiligd door controle van de router, op elke server moet nog beveiliging opkomen, op DMZ moet de buitenwereld op kunnen, op het bedrijfsnetwerk niet en is dus beter beschermd. Wel kan een firewall die meer als 2 interfaces gebruikt ook de DMZ beveiligen
    3. De routetabellen van de AS'en worden manueel bijgewerkt wrong... routetabellen worden up-to-date gehouden door dat ze naar elkaar berichten zetten die voldoen aan het BGP (inmiddels versie 4)
    4. Een ISP heeft er belang bij om een peering overeenkomst te hebben met elke andere ISP?
    5. VOIP gebruikt UDP en enkel udp omdat voIP een real-time toepassing
    6. PGP heeft certificaten en genereert een zogenaamde digitale vingerafdruk die kan gebruikt worden om na te gaan of een gebruiker echt is
    7. Via een certificaat is de eindgebruik zeker dat de server waarmee hij verbinding heeft gemaakt effectief de gevraagde server (en houder van het certificaat) is.

2011 augustus examen

Theorie

 

Praktijk

Oplossing : mkdir -p ../resources/images

Oplossing: touch versie_`date +%d%m%y`.txt

Oplossing : grep -v 'test' report.txt

Oplossing: grep -Eo '[ ]+[^ ]{4}[ ]+' report.txt > output.txt

Oplossing: openssl enc -aes-256-cbc -in topSecret.txt -out topSecret.aes -k xfile

Een oplossing: ls -l -S | awk {'print $8 " " $5;'}

2011 januari examen

2012 augustus examen

Theorie

  1. Analyse van pakketten
    1. Zoek IP-adres van de DNS server
    2. Hoeveel TCP connecties worden er opgebouwt?
    3. In pakket x wordt een http request gedaan. In welk pakket nog en waarom ziet er dat niet uit zoals in pakket x?
    4. Hoeveel data is verstuurd tijdens de connectie tussen x en y die in pakketten a tot b wordt beëindigd? Kijken naar SYN en ACK bytes
  2. Schema van een netwerk
    1. Leg volgende begrippen uit aan de hand van een schema (schema moet je zelf tekenen) : intern net, demiliteraized zone, firewall, router, webserver.
    2. Plaats een ACL waarbij enkel inkomende verbindingen op poort 80 geaccepteerd worden op het schema om de webserver beter te beveiligen.
    3. Schrijf een gegeven IPv6 adress voluit.
  3. Encryptie
    1. Geef 2 algoritmes waarbij het niet belangrijk is dat de data geheim is. Leg beide kort uit.
    2. Geef een voorbeeld van een service die met UDP werkt en wat zijn de voordelen hiervan.
  4. Waar of niet waar
    1. Een wiskundige vind een snelle manier om een product in 2 priemgetallen op te splitsen, is het RSA in gevaar?
    2. Door de komst van asymmetrische sleutels zijn symmetrische sleutels eigenlijk niet meer nuttig.
    3. Een IPSEC AH (Authentication Header) zorgt ervoor dat de header van een IP-pakket niet meer veranderd kan worden door een digitale handtekening (iets in die trand).
  5. Leg kort uit
    1. Ticket (Kerberos)
    2. Diffie Helman
    3. Internet exchange
    4. VPN

Praktijk

1. op debbie.vlan77.be staat 1 vd volgende poorten open: 1234,2345,3456,4567. Hoe kan je dit vinden in 1 lijn

2. schrijf de output die men krijgt bij verbinding met deze poort weg in ~/tmp/vraag2.txt

3. doe een ping, die dit 12 keer stuurt en om de 0,5 seconde

4. (bepaald comando, weet niet meer dewelke) geeft alle actieve bestanden, geef een lijst met diegene die het meest actief zijn.

5. iets van bob en alice willen met elkaar veilig communiceren (ze hebben al een sleutel)

2012 januari examen

Theorie

  1. Analyse van pakketten
    1. Zoek IP-adres van de DNS server
    2. Wat gebeurd er in pakketten x tot y (was de 3-way handshake)
    3. In pakket x wordt een http request gedaan. In welk pakket nog en waarom ziet er dat niet uit zoals in pakket x?
    4. Hoeveel data is verstuurd tijdens de connectie tussen x en y die in pakketten a tot b wordt beëindigd? Kijken naar SYN en ACK bytes
    5. Wat betekent de 301 status code van een http response
  2. Je krijgt de uitvoer van netstat te zien
    1. Wat is het IPv4 adres van de server
    2. Is de server een webserver?
    3. Welke poort kan je alleen aanspreken met een IPv4 adres? Kijken naar poorten in tcp en tcp6-output
    4. Is [IPv6-adres local van bovenstaande netstat uitvoer] het IPv6 adres van de server? (Was onwaar omdat de poort erbij stond)
  3. Alice wil veilig communiceren met Bob via zijn publieke sleutel. Hoe kan ze zeker zijn dat ze met Bob communiceert en niet met Trudy die de pakketten probeert te onderscheppen. Geef twee manieren hoe de uitwisseling veilig kan gebeuren en leg kort uit.
  4. Een IPv6 adres voluit in hexadecimaal uitschrijven
  5. Juist of fout + leg uit
    1. Een pakketfilter ontdekt geen virussen
    2. Het Session Initiation Protocol dient om media (audio/video) te versturen
    3. Het IPSEC AH beschermd de gehele IP header
    4. Door de komst van asymmetrische sleutels zijn symmetrische sleutels eigenlijk niet meer nuttig.
  6. Geef een voorbeeld van een service die met UDP werkt en leg uit waarom.
  7. Verklaar
    1. Ticket (Kerberos)
    2. Onweerlegbaar
    3. ACL (Access Control List)
    4. Peering

Praktijk

2013 augustus examen

Theorie

  1. Analyse van pakketten
    1. Zoek IP-adres van de DNS server
    2. Hoeveel TCP connecties worden er opgebouwd?
    3. In pakket x wordt een http request gedaan. In welk pakket nog en waarom ziet er dat niet uit zoals in pakket x?
    4. Hoeveel data is er verstuurd wanneer je aan pakket x en y zit?
  2. Je verstuurt een mail via de server mx debbie, zeg hier bij wat er gebeurt en maak gebruik van de volgende termen: smtp, DNS protocol, routering, ARP protocol, client-server model.
  3. Uitleggen bij een packet filter en een inspection firewall hoe dat je die kunt omzeilen als je gebruik maakt van passive ftp
  4. Bob en Alice hebben elk een publieke sleutel, twee manier geven hoe dat Trudy deze niet kan onderscheppen
  5. Waar of niet waar
    1. Zonder CBC is bij AES niet mogelijk om afbeeldingen te beveiligen
    2. Bij handshake heeft men 2 nonces(ofzoiets)
    3. Iets van een versleuteling bij https
    4. Door de komst van asymmetrische sleutels zijn symmetrische sleutels eigenlijk niet meer nuttig.
  6. Leg uit het is beter om IP spoofing te gebruiken bij een DOS dan gewoon de documenten te stelen(ofzoiets)
  7. Termen uitleggen
    1. Content type(http header)
    2. jitter
    3. http hijacking
    4. een tekening waarbij je moest zeggen wat er gebeurt

Praktijk

  1. Een variant op ping waarbij je een automatische ICMP doet
  2. Een reeks van mappen aanmaken(vb tmp/dir1/dir2/dir3 als dir 1 ng niet bestaat)
  3. Een code kraken die op een website staat
  4. je hebt bestanden cert.pem en cert.key je moest er voor zorgen dat die de juiste permissies kregen met chmod
  5. Een oefening met tshark

2013 januari examen

Theorie

  1. Analyse van pakketten
    1. Zoek IP-adres van de DNS server
    2. Hoeveel TCP connecties worden er opgebouwt?
    3. In pakket x wordt een http request gedaan. In welk pakket nog en waarom ziet er dat niet uit zoals in pakket x?
  2. Zet wat er gebeurt als je naar www.khleuven.be surft met je browser en gebruik hierbij de volgende termen: HTTP protocol, DNS protocol, routering, ARP protocol.
  3. Waar of niet waar + woordje uitleg.
    1. Een wiskundige vind een snelle manier om een product in 2 priemgetallen op te splitsen, is het RSA in gevaar?
    2. Door de komst van asymmetrische sleutels zijn symmetrische sleutels eigenlijk niet meer nuttig.
    3. Een IPSEC AH (Authentication Header) zorgt ervoor dat de header van een IP-pakket niet meer veranderd kan worden door een digitale handtekening.
  4. Leg de volgende termen uit: FTP in passive mode, VPN, en nog 2 anderen.
  5. Een video player streamt een video, maar deze blijft steeds haperen. Geef 2 manieren om dit te vermijden. (Jitterbuffer is er 1 van)
  6. Geef in schema vorm een woordje uitleg over recursieve en niet recursieve DNS queries.

2013-2014 samenvatting - Filip Scheir

De samenvatting voor 2013-2014 met dank aan Filip Scheir: Samenvattingen-20210617T081040Z-001.zip

2014 augustus examen

  1. Het verschil tussen ECB en CBC en waarom dat het een beter is dan het andere
  2. Waarom dat P2P beter is in het distruburen van files dan client-server
  3. Prefetchen uitleggen
  4. Kan er gezegd worden dat een CA een "Thrusted Thirth Party" is bij PKI
  5. Leg onweerlegbaarheid uit bij het gebruik van PGP
  6. Het belang van een nonce binnen authenticatie
  7. Wat is de cryptografische functie een CA
  8. Het verschil tussen end-to-end vertraging en pakketjitter
  9. Waar/Niet waar + Uitleg
    1. Kan Jitter (Variatie Delay) opgelost worden door gebruik te maken van QoS
    2. Als een hacker de Publieke Sleutel van een website in handen krijgt heeft deze toegang tot alle sessies, en alle voorgaande sessies als deze werden opgenomen (Sniffing)
    3. Een Packet-filter kan geen virussen tegenhouden
    4. Voorbeelden van applicatie gateway zijn web cache en een server
    5. Als je zo snel mogelijk een bestand wil versturen naar een verre locatie (+15 hops) dan gebruik je TCP
    6. Er zijn minder regels bij een packetfilter om een bepaalde TCP communicatie toe te staan tussen client-server dan bij stateful inspection firewall
    7. In een DMZ (Demilitarized Zone) staan geen interne servers
    8. Bij VoiP loopt verkeer van alle gesprekken via de SIP proxys
    9. Een systeem dat gebruikt maakt van HMAC is gevoelig voor replayaanvallen

2014 januari examen

  1. Waarom maakt een website gebruikt van cookies. Leg uit met behulp van een schema.
  2. Waarom is een gedistribueerde hashtabel een 'HASH'-tabel?
  3. Alle voordelen en nadelen van UDP en TCP uitleggen, en 2 voorbeelden geven waarom/wanneer je gebruik zou maken van UDP of TCP.
  4. Hoe werkt pgp en hoe garandeert het integriteit en authenticatie? Leg uit Onweerlegbaarheid/Non-repudiation
  5. Leg DASH & Manifestbestand uit + onderlinge relatie.
  6. Noem de twee soorten redundantie bij videocompressie?
  7. Hoe werkt een leaky bucketsheduler?
  8. Vraag 8 (Waar/Niet)
    1. Kan Jitter (Variatie Delay) opgelost worden door gebruik te maken van QoS?
    2. Als bij een diefstal de Private Sleutel van een Certification Authency (CA) gestolen wordt, heeft dit dan invloed op vooraf uitgedeelde certificaten door deze sleutel?
    3. Als een hacker de Private Sleutel van een website in handen krijgt heeft deze toegang tot alle sessies, en alle voorgaande sessies als deze werden opgenomen (Sniffing) ?
    4. Een Packet-filter kan geen virussen tegenhouden.
    5. ...(nog een 8 tal)

2015 augustus examen

  1. Bespreek de 2 manieren die er zij om weergavevetraging tegen te gaan bij jitter + schema.
  2. Hoe helpt leaky bucket bij iets van bandbreedte + schema?
  3. Als netwerkbeheerder bij ICMP-ZERO moet je de firewall configureren zodat de DMZ niet kan gemapt worden door middel van traceroute. Teken deze configuratie en schrijf in pseudocode de FW-regels.
  4. Een audiostukje is gesampeld aan 16 000 samples per seconde. Er zijn 12 000 verschillende niveaus. Wat is de bitrate wanneer het CMP gecodeerd is? Toon ook de berekening.
  5. Leg volgende bewering uit: IPsec is een veiligheidsdeken.

waar of niet waar + leg uit (hierop krijg je punten)

  1. In de HTTP header field byterange krijgt de gebruiker een indicatie van de grootte van het object.
  2. Het deffel-hillman algoritme is een hashfunctie.
  3. Een hasfunctie is veiliger dan een checksom.
  4. Een DNS requests kan enkel interactieve requests aanvragen. (ja zo stond dat op het examen. Ik weet het, die zin klopt niet).

2016 januari examen

Theorie

Dit examen werd in 2017, 2018 en 2019 getoond als voorbeeldexamen.

Deel 1: meerkeuzevragen

Principe: Per vraag zijn er vier tot 6 stellingen gegeven. Duid telkens aan welke allemaal juist zijn. Het aantal juiste mogelijkheden wordt gegeven. Elke aangeduide mogelijkheid moet juist zijn. Als de juiste antwoorden bv. zijn 'A, F & G' en je duidt 'A, B & G' aan dan is dit volledig fout. De vragen werken ook volgens het principe van eliminatie; er worden ook stellingen over ongeziene stof gegeven en door te elimineren wat je weet van de geziene stof kan je besluiten of de onbekende dingen juist zijn.

1) Welke dingen zijn van toepassing op IPsec transportmode:

2) Welke twee protocollen zorgen voor confidentialiteit van uitgewisselde data

3) Welk systeem kan aanvallen inline tegenhouden. Bv. hacker wilt website defacen via Joomla Exploit.

4) Beweringen over Telnet

5) Iets over access lists

6) Welke tools om mail te versturen

7) Beweringen over IPsec-verbinding


8) ACC’s

9) Beweringen over NAT

10) Iets over diensten die IPsec levert. Mensen struikelden hier over het woordje diensten, want in de lijst stonden implementaties ook.

11) Welke zijn block cyphers? Dit was een kutvraag volgens Swennen. Afleiden door reductie.

12) Alice mailt Bob. Je moet blijkbaar zo’n constructies kunnen begrijpen:

13) Applicaties bovenop UDP

14) Beweringen over HTTP

15) Welke functies noodzakelijk voor IPsec?

16) Welk van onderstaande servers ook application gateway

17) Packet Jitter

18) Router die QoS algoritme WFQ samen met ???? kan garantie leveren op

19) HTTP-conversatie, er stond geen 200 dus dat was sowieso al niet goed

20) Router in welke laag OSI-model? Hier was Swennen het meest in teleurgesteld!!!

21) Beweringen ESP IPsec


22) TCP source ports.


23) Welke van de volgende zaken worden niet voorzien door TCP (transmission control protocol)?

Deel 2: open vragen

1) In bijlage staat een wiresharkoverzicht van een verbinding.
1a) Hoeveel verbindingen werden er gemaakt? Aan wat zie je dit?
Twee. Dit vind je door SYN, SYNACK, ACK te tellen.
1b) In pakket 8 zien we dat er een HTML-request is. In welk pakket is dit nog zo en waarom zien we dit niet zo als in pakket 8?
Andere is HTTPS.
1c) Hoeveel data (bytes) is er verstuurd in de connectie die op lijn 29 wordt beëindigd.
ACK = 2626 -> seq 2626 = aantal bytes
Ergens was er ook nog een vraag over (a * b)mod^n^. Hierbij moest je niet rekenen, is formule die je zo kunt omzetten.
2) Geef een volledig schema over hoe mail van bij Alice die op haar mailclient (Mozilla Thunderbird) zit vanuit een telenetnetwerk tot aan Bob (ucll) geraakt. Volgende zaken moeten minstens voorkomen
DNS records, DNS, TLD, IMAP, SMTP, (nog iets denk ik maar ben het vergeten).
Die lijst met dingen die je moet aanduiden staat er niet voor niets. Die helpt je je antwoord logisch op te bouwen. Zie dat je eerst op kladblad tekent.

2017 juni examen

Theorie

Praktijk

Praktijkexamen 22/05/2017

Words with 14 letters: word1 word2 word3
Words with 15 letters: word4 word5
...
for n in 14 15 16; do echo "Words with $n letters:" $(grep -P "^.{$n}$" dutch | grep -vP '(.).*\1'); done
tshark -r ftp_bruteforce.pcap -Y 'ftp.request.command == USER' -T fields -e ‘ftp.request.arg’ | sort -u
echo 'Time=' $(date +'%T (%x)') | tr / -
The file ends with '==' indicating base64 padding: openssl enc -d -base64 < secret
echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -fingerprint -serial -pubkey -noout

Praktijkexamen 24/05/2017

ssh -L 10000:darthvader.uclllabs.be:443 user@leia.uclllabs.be -p 22345
grep -P '^(.)(.).\2\1$' dutch
grep -vP '^#' /etc/debconf.conf
tshark -r ftp_bruteforce.pcap -Y 'ftp.request.command == USER' -T fields -e ‘ftp.request.arg’ | sort -u
echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -fingerprint -serial -pubkey

2018 juni examen

Theorie

Praktijk

Praktijkexamen 23/05/2018

for i in {1200..1300}; do if wget -q http://darthvader.uclllabs.be/nw2/phone/ --http-user=admin --http-password=$i; then echo $i; break; fi;done;
cat /home/logs/secret | base64 -d
cat /etc/debconf.conf | grep -Ev "^#"
echo -ne "GET /nw2/images/image1.jpg HTTP/1.0\r\n\r\n" | nc darthvader.uclllabs.be 80 > image1.jpg; cat image1.jpg | tail -n +13 > imagetester.jpg
*.1.cnw2.uclllabs.be. 3600 IN A 193.191.176.1
*.2.cnw2.uclllabs.be. 3600 IN A 193.191.176.2
*.3.cnw2.uclllabs.be. 3600 IN A 193.191.176.3
*.4.cnw2.uclllabs.be. 3600 IN A 193.191.176.4
*.5.cnw2.uclllabs.be. 3600 IN A 193.191.176.5
*.6.cnw2.uclllabs.be. 3600 IN A 193.191.176.6
*.7.cnw2.uclllabs.be. 3600 IN A 193.191.176.7
*.8.cnw2.uclllabs.be. 3600 IN A 193.191.176.8
*.9.cnw2.uclllabs.be. 3600 IN A 193.191.176.9
*.10.cnw2.uclllabs.be. 3600 IN A 193.191.176.10
dig axfr cnw2.uclllabs.be @ns2.uclllabs.be | awk '{print $1,$2,$3,$4,$5}' | grep "IN A" | sort -V

Praktijkexamen 22/05/2018

for pin in {1200..1300}; do if wget -q --http-user='admin' --http-password=$pin http://darthvader.uclllabs.be/nw2/phone; then echo $pin; break; fi; done
grep -P '^(.)(.).\2\1$' dutch
grep -vP '^#' /etc/debconf.conf
tshark -r ftp_bruteforce.pcap -Y 'ftp.request.command == USER' -T fields -e ‘ftp.request.arg’ | sort -u
echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -fingerprint -serial -pubkey

2019 extra oefeningen + oplossingen - Lars, Martijn, Jonas

Met dank aan de Github van Martijn

Opgave: cnw2.pdf

Met dank aan Lars Lemmens

Oplossingen

Met dank aan Jonas Berx

Monitoraat Netwerken - By JONAS BERX
 
# Neem niet zomaar de code over, zoek zelf een oplossing :) (man ...) of (... --help)
# Google is ook nog altijd je vriend
# Niet alle oefeningen zijn 100% juist
# Please geen haat als je uitkomst niet klopt
# Ik ben maar een arm studentje uit UCLL dat graag op Netwerken erdoor wilt zijn
# XXX JONAS XXX
#
 
1) wget -q -O -  http://crl3.digicert.com/TERENASSLCA3.crl | openssl crl -inform DER -text -noout | grep "Revocation Date" | wc -l
 
2) ssh -p 22345  rNummer@leia.uclllabs.be
 
3) ping 127.0.0.1 -c $(ls | grep \.crl$ |wc -l)
 
4) tshark -r Cnw2_ftp_bruteforce.pcap -Y 'ftp.request.command==PASS' -T fields -e 'ftp.request.arg' 2>/dev/null| sort | uniq -c | sort -rn | head -3 | cut -d ' ' -f 7
 
5) gebruik de filter : 'http.request.command==POST'
 
6) nc -z -n -v 193.191.177.1 1-66535 |& grep succeeded ----------- nmap -p- 193.191.177.1 --max-rate 50 (Max rate 50 is redelijk traag aangezien er +65000 poorten zijn)
 
7) who | awk '{print $1,$3}' | while read user time; do   echo $user $(($(($(date +%s) - $(date -d "$time" +%s)))/60)) minutes; done | sort | uniq -c (Klopt niet 100% maar geeft je wel de tijd in minuten)
7A) who -H (Simpele oplossing beter te combineren met 7B)
7B) who | awk '{print $3,$4,$1}' | sort | head -1
 
8) tar -cvf archive.tar /home/LDAP/r0748969 | openssl enc -aes-128-cbc -in archive.tar -out archive.tar.aes; openssl enc -aes-128-cbc -in archive.tar.aes -out archive.tar.aes.aes (GOOGLE : Tar on the fly -> geen tussenbestanden)
 
9)  ss -lnt4 | awk '/LISTEN/{print $4}' |cut -d ':' -f 2 | grep -vP '(.).*\1'
 
10) tshark -r Cnw2_ftp_bruteforce.pcap -Y 'ftp.response.code==230' (Juiste code wel : 230 maar niet juiste antwoord.. moet nog de login gegevens van de successfull login vinden)
 
11) #geen moeite in deze gestoken
 
12) grep -P '^([A-Za-z])([A-Za-z])\2\1$' (achteraf nog een dict toevoegen om in te zoeken)
 
14) ls -ld (-d staat voor directory)
 
15) String = "TGludXggUlVMRVM=" echo TGludXggUlVMRVM= | openssl enc -d -a
 
16) nmap 193.191.177.1 -p- -r --open -sT
 
39) cat /usr/share/dict/dutch | grep -vP '(.).*\1' | grep -P '^[a-zA-Z]{5}$' (voorlaatste)
 
#rest zal deze week er wel bijkomen.. Ik doe m'n best
#Good luck all
#De antwoorden hieronder zijn van het examen dat in de les overlopen is
 
Voor examen : History en dan nummer geven -> handig om op het examen niet je code over te schrijven maar gewoon het nummer van het command te geven.
-----------------------------------------------------------------------
!!!!!!!!!!!!!!!!!!!!!!!!!! 2>/dev/null = vuilnisbak !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
------------------------------------------------------------------------
EXAMENVRAGEN
1)for foo in 14 15 16; do echo "Words with $foo letters:" $(echo "grep -vP '(.).*\1' /usr/share/dict/dutch | grep -P '^.{$foo}$'"| sh);done
 
2) tshark -r Cnw2_ftp_bruteforce.pcap -Y 'ftp.request.command==USER' -T fields -e 'ftp.request.arg' | sort | uniq -c | sort -rn
 
3) date '+Time = %X (%X)' OF echo date : $(date +%Y.%m.%d)
 
4)  cat secret | base64 -d of cat secret | openssl enc -d -a
 
5) echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -noout -pubkey -serial -fingerprint -enddate

2019 juni examen

Theorie


DE VOLGENDE 3 VRAGEN WAREN EXACT HETZELFDE OP HET HEREXAMEN!

Praktijk

Praktijkexamen 1

echo | openssl s_client -connect facebook.com:443 | openssl x509 -text -noout | grep -o 'DNS' | wc -l

 

cat /usr/share/dict/dutch | grep -P '^[a-zA-Z]{11}$' | grep -vP '(.).*\1'
cat /etc/debconf.conf | grep -vP '^#'

 

tshark -r ftp_bruteforce.pcap -Y 'ftp.request.command == USER' -T fields -e ‘ftp.request.arg’ | sort -u

 

alfa.key matches to beta.crt gamma.key matches to delta.crt

for key in $(ls -1 *.key); do for crt in $(ls -1 *.crt); do if [ [ $(openssl rsa -in $key -noout -modulus | md5sum) == $(openssl x509 -in $crt -noout 
 -modulus | md5sum) ]]; then echo $key matches $crt; fi; done; done

--> er is een bestand '/home/logs' op leia waar je dit mee kan testen

Praktijkexamen 2

Words with 14 letters: bedrijfsomvang ... Words with 15 letters: ...

for foo in 14 15 16; do echo -e "Words with $foo letters:" && grep -P "^.{$foo}$" /usr/share/dict/dutch | grep -Pv '(.).*\1';done

secret 'mysecret' using the Diffie Hellman algorithm. Alice wants to display the contents of the file directly on her screen in stead of storing it locally and then opening it. Use a suitable encryption algorithm. The data is sent over a medium which only allows ASCII text. Alice is logged in on debbie and Bob on the virtual machine.

the 5 IP adresses that contacted the web server the most. The apache log is located in /home/log. Create a correct oneliner. The output should look something like this: (count IPs) 8000 10.10.10.10 ... 82 81.30.45.89

cat /home/logs/apache_google.log | awk '{print $1}' | sort | uniq -c | sort -rn | head -5

Praktijkexamen 3

grep -P '^([a-zA-Z])([a-zA-Z])[a-zA-Z]\2\1$' /usr/share/dict/dutch
echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -fingerprint -serial -pubkey -noout
mkdir -p ~/temp/dir1/dir2/dir3

2019 oplossingen labo 0 - Lars Lemmens

Met dank aan de Github van Martijn en natuurlijk Lars Lemmens

LABO 0

Exercise 24

Create 2 files with random text. Then create a third file containing the contents of the two other files

1) echo 'some random text' > file1
2) pwgen -n1 > file2 
3) cat file1 file2 > file3

Exercise 25

List all home directories which are open for other users (group or others should have r,w or x rights)

• ls -l /home/LDAP/ | grep -v 'drwx------' | grep -v '^total' | tr -s ' ' | cut -d ' ' -f9
• ls -l /home/LDAP/ | grep -v 'drwx------' | grep -v '^total' | awk '{print $9}'
• ls -l /home/LDAP/ | grep -vP '^(drwx------|total)'| awk '{print $9}'
• ls -l /home/LDAP/ | awk '$1 !~ /drwx------|total/{print $9}'

Exercise 26

List all lines in the file /usr/share/dict/dutch containing the string 'rare'

• cat /usr/share/dict/dutch | grep rare
• grep rare /usr/share/dict/dutch

Exercise 27

Only show the columns with filenames and permissions of the files in your homedirectory. (tip: use ls and cut)

• ls -l ~ | grep -v '^total' | tr -s ' ' | cut -d ' ' -f1,9

Exercise 28

Sort the lines from 27 in reverse alphabetical order

• ls -l ~ | grep -v '^total' | tr -s ' ' | cut -d ' ' -f1,9 | sort -r -k2

Exercise 29

Use the command cal to find out on which day of the week your birthday is in 2050 and write your output to a newly created file

• ncal -m 6 2050 | grep ' 9 ' | cut -d ' ' -f1 > file
• cal -N -m 6 2050 | grep ' 9 ' | cut -d ' ' -f1 > file

Exercise 30

Append the sentence 'THE END' to the file you created in the previous exercise without opening this file in an editor (hence: use a one-liner)

• echo 'THE END' >> file

# >> makes a file and saves it

Exercise 31

Create a subdirectory TEST in your homedir. Now create some files in it using this command line (and make sure you understand what happens!)

for foo in `seq 1 9`; do touch "file $RANDOM"; done && touch 'file keep me'

How can you remove all files except the file “file keep me” with just one 'oneliner'"

1) mkdir ~/TEST; cd ~/TEST
2) for foo in {1..9}; do touch "file $RANDOM"; done && touch 'file keep me'

• rm file\ [0-9]*
• ls file\ [0-9]* | while read file; do rm "$file";done
• ls -1 | grep -v 'file keep me' | xargs -d '\n' rm
• find . -type f ! -name 'file keep me' -delete

Exercise 32

List the name and permissions of the first 10 directories in /etc.

Sample output: 
drwxr-xr-x /etc/ 
drwxr-xr-x /etc/alternatives 
drwxr-xr-x /etc/apache2 
drwxr-xr-x /etc/apache2/conf.d 
drwxr-xr-x /etc/apache2/mods-available 
drwxr-xr-x /etc/apache2/mods-enabled 
drwxr-xr-x /etc/apache2/sites-available 
drwxr-xr-x /etc/apache2/sites-enabled 
drwxr-xr-x /etc/apt d
rwxr-xr-x /etc/apt/apt.conf.d"

• ls -l /etc | head -10 | grep -v '^total' | awk '{print $1 " " $9}'

Exercise 33

Same question as #32, but now also omit all error messages. "

• ls -l /etc 2>/dev/null | head -10 | grep -v '^total' | awk '{print $1 " " $9}'

Exercise 34:

List the name and permissions of all files in the /etc directory containing the word 'host' in their name. Do this without the use of the commands grep and/or awk."

• find /etc/ -type f -name '*host*' 2>/dev/null | xargs -d '\n' ls -l # (recursive search)
• find /etc/ -maxdepth 1 -type f -name '*host*' 2>/dev/null | xargs -d '\n' ls -l
• ls -ld /etc/*host* | tr -s ' ' | cut -d ' ' -f1,9 # (also show files of type directory)   
• ls -ld /etc/*host* | sed -e '/^d.*/d' | tr -s ' ' | cut -d ' ' -f1,9

 

2019 oplossingen labo 1 - Lars Lemmens

Met dank aan de Github van Martijn en natuurlijk Lars Lemmens

LABO 1

In order to connect to a remote SSH server leia.uclllabs.be in this example, execute the following command

'user:~$' • ssh r1234567@leia.uclllabs.be -p 22345

The client configuration file can make your life easier because default command line options could be specified in this configuration file

Normally you would use the following command to log in to leia

'user:~$' • ssh -p 22345 r1234567@leia.uclllabs.be  

"FILE: ~/.ssh/config"
    Host leia
    HostName leia.uclllabs.be
    Port 22345
    User r1234567

The following command creates an ssh tunnel. Local tcp port CPORT (on your laptop) will be tunneled through GATEWAY to SERVER port

'user:~$' • ssh -f GWUSERNAME@GATEWAY -L CPORT:SERVER:SPORT -N

Try it yourself: There is a website running - https://darthvader.uclllabs.be/nw2/lab1 which is only accessible from 193.191.177.1. That's the IP address of leia.uclllabs.be.

'user:~$' • ifconfig | grep -B1 inet

With this command, you can create an ssh tunnel between server leia.uclllabs.be and the webserver darthvader.uclllabs.be.

'user:~$' • ssh -p 22345 -f r0123456@leia.uclllabs.be -L 10000:darthvader.uclllabs.be:443 -N

First find the ssh process to close:

'user:~$' • ps fauxw | grep darthvader

Next send a sigterm signal to the correct pid (process identifier) = second column in ps fauxw output

'user:~$' • kill 12345

And if you need to close all running ssh sessions/tunnels use the following command:

'user:~$' • killall ssh

By default kill sends a SIGTERM signal (similar to clicking on the X to close a window (Chrome, Notepad, Gnome-terminal,..). If you need to force close an application, send the SIGKILL signal:

'user:~$' • kill -9 12345
'user:~$' • killall -9 ssh

Use a text based browser on leia to verify the remote website is accessible through the ssh tunnel.

'user:~$' • lynx https://localhost:10000/nw2/lab1-all-but-leia
'user:~$' • curl -k -s https://localhost:10000/nw2/lab1-all-but-leia/ | html2text

OpenSSH has built-in support for dynamic port forwarding via the SOCKS proxy protocol. This command turns your SSH client (on your laptop) into a SOCKS proxy server: "

'user:~$' • ssh -f user@GATEWAY -D 10000 -N -p port

There are 3 different levels of debug modes that can help troubleshooting issues. With the -v option SSH prints debugging messages about its progress.

This is helpful in debugging connection, authentication, and configuration problems. Multiple -v options increase the verbosity. Maximum verbosity is three levels deep.

'user:~$' • ssh leia -v
'user:~$' • ssh leia -vv
'user:~$' • ssh leia -vvv

This command will aid you in finding an available tcp port: "

'user:~$' • netstat -lnt | grep -oP ':\K[^:][0-9]+' | sort -un

For instance, we can scan all ports up to 1000 by issuing this command:

'user:~$' • nc -vz leia.uclllabs.be 1-1000

"Messages returned by Netcat are sent to standard error. You can send the standard error messages to standard out, which will allow filtering the results. Stderr can be redirected to stdout via the 2>&1 bash syntax. Then use grep to filter

Alternatively you could use |& as a shorthand for 2>&1 |. "

'user:~$' • nc -z -n -v 193.191.177.1 1-1000 2>&1 | grep succeeded
'user:~$' • nc -z -n -v 193.191.177.1 1-1000 &| grep succeeded

Netcat is a very slow TCP port scanner as it will wait for a TCP timeout for every port it tries. Add option -w 1 to increase scanning speed, and execute this command on leia to circumvent slowdown due to firewalled ports.

Netcat isn't designed to scan for open ports, it's functionality is very limited. If you need to scan for open ports, use a real portscanner like Nmap"

'user:~$' • nmap -p1-1000 193.191.177.1

Once again, you need to choose one end of the connection to listen for connections.

However, instead of printing information onto the screen, you will place all information straight into a file

'user:~$' • nc -l -p 10000 > received_file

On the second computer, create a simple text file by typing: "

'user:~$' • echo "Hello, this is a file" > original_file

You can now use this file as an input for the Netcat connection you will establish to the remote listening computer.

The file will be transmitted just as if you had typed it interactively: "

'user:~$' • nc -l -p 10000 < original_file

On the receiving end, you can anticipate a file coming over that will need to be unzipped and extracted by typing: "

'user:~$' • nc -l -p 10000 | tar xzvf -

On the side with the directory contents you want to transfer, you can pack them into a tarball and then send them to the remote computer through Netcat:

'user:~$' • tar -czf - * | nc leia.uclllabs.be 10000

In the following example, we create a full backup of our home directory on leia (all files and folders) using tar - Netcat method.

Execute this on leia: "

'user:~$' • tar -cz ~ | nc -l -p 10000

And this on your laptop (the machine receiving backups):

'user:~$' • cd /path/to/where_I_want_to_store_my_backup
'user:~$' • nc leia.uclllabs.be 10000 | tar -xzf -

This is just one example of transferring more complex data from one computer to another. Another common idea is to use the dd command to image a disk on one side and transfer it to a remote computer.

'user@leia:~$' • tar -cz ~ | pv | nc -l -p 10000

'user@laptop:~$' • nc leia.uclllabs.be 10000 | pv > backup.tar.gz
'user@leia:~$' • tar -cz ~ | pv | nc '-N' -l -p 10000

'user@laptop:~$' • nc -d leia.uclllabs.be 10000 | pv > backup.tar.gz
'user@laptop:~$' • nc leia.uclllabs.be 10000 </dev/null | pv | tar xzf -

Exercise 1:

How do you verify if the packages openssh-server and openssh-client are installed on your Debian system? (Hint: dpkg -l ...)"

'user:~$' • dpkg -l openssh-server
'user:~$' • dpkg -l openssh-client

Exercise 2:

How do you verify if the openssh-server is running?

'user:~$' • systemctl status ssh

Exercise 3:

How to check which port is used by the SSH server daemon? (Hint: netstat, ss or lsof)

'root #' • netstat -lntp | grep sshd
'root #' • ss -lntp | grep sshd
'root #' • lsof -i tcp | awk '$1=="sshd" && $10=="(LISTEN)" {print $9}' | cut -d ':' -f2 | sort -u

Exercise 4:

How do you disconnect from a remote SSH session?

'user:~$' • exit
'user:~$' • logout
'user:~$' • <CTRL>+d

Exercise 5:

Is there a config file for the OpenSSH server? If so, where is it located in the file system tree?

Yes: '/etc/ssh/sshd_config'

Exercise 6:

Create and demonstrate a simple web server with Netcat.

'user:~$' • while true; do { echo -e "HTTP/1.1 200 OK\r\n$(date)\r\n\r\n<h1>hello world from $(hostname) on $(date)</h1>" | nc -vl -p 10000; } done

2019 oplossingen labo 2 - Lars Lemmens

Met dank aan de Github van Martijn en natuurlijk Lars Lemmens

LABO 2

What is the IP address of your computer?

What is the status code returned from the server to your browser?

When was the HTML file that you are retrieving last modified on the server?

'user:~$' • echo -ne 'HEAD /HTTP-Wireshark-file1.html HTTP/1.1\r\nHost:  virtualhostname.x.cnw2.uclllabs.be\r\n\r\n' | nc localhost 80 | grep 'Last-Modified:'

'user:~$' • tshark -r http.pcapng -Y http -T fields -e http.last_modified

How many bytes of content are being returned to your browser?

What software and version is the web server running?

'user:~$' • tshark -r http.pcapng -Y http.server -T fields -e ip.src -e http.server | sort -u

Explain in detail the above tshark command.

What TCP ports are in use at the client and the server during your browsing session?

'user:~$' • tshark -r http.pcapng -Y http -T fields -e tcp.port | sort -u

Exercise 1:

Which HTTP method was used the most during the entire browsing session?

'user:~$' • tshark -r http.pcapng -Y http.request.method -T fields -e http.request.method | sort | uniq -c | head -1 | awk '{print $2}'
'user:~$' • tshark -r http.pcapng -Y http.request.method -T fields -e http.request.method | sort | uniq -c | awk 'NR=1{print $2}'

In case you would like to automate this: With tshark and a Bash loop"

'user:~$' • tshark -r http.pcapng -Y 'http.request.method==GET' -T fields -e tcp.srcport | sort -u | while read PORT;do tshark -r http.pcapng -Y "tcp.dstport==$PORT && http.server contains Apache" -T fields -e ip.src;done | sort -u

Exercise 2:

How many HTTP GET request messages did your browser send?

'user:~$' • tshark -r http.pcapng -Y http.request.method==GET | wc -l

To which Internet addresses were these GET requests sent?

'user:~$' • tshark -r http.pcapng -Y http.request.method==GET -T fields -e ip.dst | sort -u

Exercise 5:

Use Netcat to download these images. check the echo -ne options or use printf. If needed, slow down netcat with option -i. The image part in the HTTP stream starts after a blank line.

'user:~$' • echo -ne "GET /nw2/images/image1.jpg HTTP/1.1\r\nHost: darthvader.uclllabs.be\r\n\r\n" |\ nc darthvader.uclllabs.be 80 | sed '1,/^\r/d' > image1.jpg

'user:~$' • echo -ne "GET /nw2/images/image1.jpg HTTP/1.1\r\nHost: darthvader.uclllabs.be\r\n\r\n" |\ nc darthvader.uclllabs.be 80 | grep -A9999999999999999 -B0 -Pa 'JFIF' > image1.jpg

Exercise 7:

Use httpie, a cURL-like tool for humans to inspect the various HTTP headers in request and responses. Connect to various websites and explain the use of the HTTP headers.

'user:~$' • http -v -a Rey:StarWars http://darthvader.uclllabs.be/nw2/private/

Exercise 8:

A simulated phone is running at http://darthvader.uclllabs.be/nw2/phone/. Create a oneliner to bruteforce the pincode. Tip: pincode range: 1200-1300

'user:~$' • for foo in {1200..1300}; do if wget -q --http-user='admin' --http-password=$foo http://darthvader.uclllabs.be/nw2/phone; then echo $foo;break;fi;done

Exercise 9:

"Put the following text.txt on your web server. This text contains the string Goed bezig :-)

Write an HTTP request by using the Range header so your web server will only return this exact string 'Goed bezig :-)'. Try to do this by only using netcat

'user:~$' • curl http://your.server.name/output.txt -i -H "Range: bytes=1-"
'user:~$' • echo -ne "GET /output.txt HTTP/1.1\r\nHost: your.server.name\r\nRange: bytes=1-\r\n\r\n" | nc your.server.name 80

Exercise 10:

This can be accomplished by sending the output of tshark or tcpdump to STDOUT instead of a regular file. Direct this STDOUT stream to Wireshark running on your local computer.

'root #' • ssh myserver.X.cnw2.uclllabs.be tcpdump -nli eth0 not tcp port 22345 -s0 -w - | wireshark -nki -

'root #' • ssh myserver.X.cnw2.uclllabs.be 'tshark -nli eth0 -f "not tcp port 22345" -s0 -w -' | wireshark -nki -

Exercise 11:

Capture some HTTP traffic while browsing several websites and save it to the file http.pcapng.

You can also use the test capture in /home/logs on leia. create a CLI oneliner which parses the captured file http.pcapng and displays all HTTP server strings which do not contain Apache.

 

Only the commands tshark and sort are allowed.

'user:~$' • tshark -r http.pcapng -Y 'http.server && !(http.server contains Apache)' -T fields -e http.server | sort -u

Exercise 12:

This exercise is a small variation of the previous one. Count and sort all HTTP server strings which do not contain Apache in HTTP responses on your GET requests.

'user:~$' • tshark -r http.pcapng -Y '!(http.request.method==GET)' -T fields -e tcp.srcport | sort -u | while read PORT;do tshark -r http.pcapng -Y "tcp.dstport==$PORT && http.server && !(http.server contains Apache)" -T fields -e http.server;done | sort | uniq -c | sort -rn

2019 oplossingen labo 3 - Lars Lemmens

Met dank aan de Github van Martijn en natuurlijk Lars Lemmens

Labo 3

Match one or more d characters: d dd ddd dddd "

'user@:~$' • grep -P 'd+' file

'user@:~$' • cat file | grep -P 'd+'

Color and colour are different spellings of the same word.

Color is the preferred spelling in American English, and colour is preferred in all other main varieties of English. The following regex matches both. "

'user@:~$' • grep -P 'colou?r' file

Match wh following by one, two or three e character: 'whe whee wheee'

'user@:~$' • grep -P 'whe{1,3}' file

Match either gray or grey

'user@:~$' • grep -P '{gray|grey}' file

Let's say you want to match a text like !abc! or !123!. Only these two are possible, and you want to capture the abc or 123.

'user@:~$' • grep -P '!(abc|123)!' file

Search /usr/share/dict/dutch for all words which end in 'vuur', without matching the word 'vuur' itself.

'user@:~$' • grep -P '^.+vuur$' /usr/share/dict/dutch

List all words which contain 32 or more letters.

user@:~$' • grep -P '^.{32}$' /usr/share/dict/dutch

List all words starting with the letter 'b', ending with the letter 'l' which are exactly 4 letters long. Capitalize the output

'user@:~$' • grep -E '^b.{2}l$' /usr/share/dict/dutch | tr [:lower:] [:upper:]
    
'user@:~$' • perl -ne 'print uc if /^b.{2}l$/' /usr/share/dict/dutch

List all palindromes with exactly 4 characters

```
'user@:~$' • grep -P '^([A-Za-z])([A-Za-z])\2\1$' /usr/share/dict/dutch

'user@:~$' • perl -lne 'print if $_ eq reverse && length($_) eq 4' /usr/share/dict/dutch
```

Exercise 1:

List all words out of the file /usr/share/dict/dutch which contain 4 or 5 consecutive vowels.

```
'user@:~$' • cat /usr/share/dict/dutch | grep -P '[aeiou]{4,5}'
```

Exercise 2:

Count the number of words out of the file /usr/share/dict/dutch which which start with 'ver', and end with 'en'. ('verplaatsen' is ok, 'overkomen' and 'vertrek' are not ok)

```
'user@:~$' • grep -P '^ver.*en$' /usr/share/dict/dutch | wc -l
```

Exercise 3:

In those annoying night television games people must guess words. Given are all the letters the word consist of and a list of dots, one for every letter.

E.g. We are looking for a 23 letter word with a 'v' in position 8: '.......v...............'. Use the letters 'enrtiscau' for the other positions."

```
'user@:~$' • cat /usr/share/dict/dutch | grep -P '[enrtiscau]{7}v[enrtiscau]{15}'
```

Exercise 4:

Show 'System load = X Y Z' replacing X, Y and Z by the values displayed by the uptime command.

```
'user@:~$' • echo "System load =" $(uptime | awk -F': ' '{print $2}'| tr -d ',')
```

Exercise 5:

List the usernames of the students who logged in from outside of the UCLL network.

```
'user@:~$' • who | grep -Pv '(.*)\s+pts.*\s+\(10\.|tmux' | awk '/^r[0-9]/{print $1}' | sort -u
```

Exercise 6:

How many times have students logged into leia from outside the UCLL network?

```
'user@:~$' • last | grep -Pv '.*?pts.*?\s+10\.' | awk '/^r[0-9]/{print $1}' | wc -l
```

Exercise 7:

Show the file /etc/debconf.conf on screen without comment lines (i.e. lines starting with a #)

```
'user@:~$' • cat /etc/debconf.conf | grep -vP '^#'
```

Exercise 8:

List all unique IP addresses that contacted your Apache web server.

```
'user@:~$' • cat /var/log/apache2/wiki-ssl-access.log | awk '{print $1}' | sort -u
```

Exercise 9:

List all unique IP addresses that contacted the ssh daemon of your Apache web server.

```
'user@:~$' • cat /var/log/auth.log | grep -oP 'sshd.*?\K[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | sort -u
```

Exercise 10:

Create a regular expression to match all words in the dictionary /usr/share/dict/dutch which with 10 unique letters.

```
'user@:~$' • cat /usr/share/dict/dutch | grep -P '^.{10}$' | grep -vP '(.).*\1'
```

Exercise 11:

To combat spam, a mail server administrator wants to reject mail coming from home users. The IP addresses home users always seem to connect from have hostnames like this: ip.domain. Create a regex which matches all these host names.

```
'user@:~$' • cat mail.log | grep -oP 'NOQUEUE: reject: RCPT from \K[0-9]{1,3}.*?\[' | tr -d '['
```

Exercise 12:

List all unique firefox 2.0.0.x versions used to connect to www.khleuven.be. Use log file /home/logs/apache_google.log. "

```
'user@:~$' • cat apache_google.log | grep -oP 'Firefox\/2\.0\.0\.[0-9]+' | sort -n -t '.' -k4 -u
```

Exercise 13:

List all words with 14, 15 or 16 unique letters.

```
'user@:~$' • for foo in 14 15 16; do echo "Words with $foo letters:" $(echo "grep -vP '(.).*\1' /usr/share/dict/dutch | grep -P '^.{$foo}$'"| sh);done

'user@:~$' • for foo in 14 15 16; do echo "Words with $foo letters:" $(grep -vP '(.).*\1' /usr/share/dict/dutch | grep -P "^.{$foo}$");done

'user@:~$' • for foo in 14 15 16; do echo "Words with $foo letters:" && echo "grep -vP '(.).*\1' /usr/share/dict/dutch | grep -P '^.{$foo}$'"| sh;done

'user@:~$' • for foo in 14 15 16; do echo "Words with $foo letters:" && grep -vP '(.).*\1' /usr/share/dict/dutch | grep -P "^.{$foo}$";done
```

2019 oplossingen labo 4 - Lars Lemmens

Met dank aan de Github van Martijn en natuurlijk Lars Lemmens

Labo 4

What is the IP address of the client and what IP address is used by the server?

Which protocol was used to find the IP address of the FTP server.

Does FTP use UDP or TCP? Why?

Is the session using active or passive FTP?

Who chooses the FTP version, active or passive? Is it the client or the server?

Sketch the three-way handshake used to negotiate the initial sequence numbers. Do this both for the relative and the real sequence numbers.

What is the benefit in using relative sequence numbers in Wireshark/Tshark?

Which credentials were used to login to the FTP service?

'user@:~$' • tshark -r Cnw2_ftp.pcap -Y "tcp.srcport == $(tshark -r Cnw2_ftp.pcap -Y 'ftp.response.code == 230' -T fields -e tcp.dstport) && ftp.request.command == USER" -T -e ftp.request.arg

"Step 1:

When a user's login attempt is successful, the FTP server answers with FTP response code 230 <- Response code: User logged in, proceed (230).

This message is sent to the client using it's chosen TCP port. This very same TCP port is used by the client for every packet sent in the control connection.

So we know the client will use this port as TCP source port when profiding the FTP username. Thus the first step is to find this TCP port:

See Cnw2 theory - Chapter 2: Application Layer: Active vs Passive FTP

'user@:~$' • tshark -r Cnw2_ftp.pcap -Y 'ftp.response.code == 230' -T fields -e tcp.dstport

Step 2:

The port we just found is the TCP port the client uses for the FTP control connection.

When using this port as TCP source port in our display filter, we'll only list packets sent from client to FTP server

'user@:~$' • tshark -r Cnw2_ftp.pcap -Y "tcp.srcport == $(tshark -r Cnw2_ftp.pcap -Y 'ftp.response.code == 230' -T fields -e tcp.dstport)"

Step 3:

We're only interested in the packet containing the username, so let's add 'ftp.request.command == USER' to the display filter:

'user@:~$' • tshark -r Cnw2_ftp.pcap -Y "tcp.srcport == $(tshark -r Cnw2_ftp.pcap -Y 'ftp.response.code == 230' -T fields -e tcp.dstport) && ftp.request.command == USER"

Step 4:

And finally use the tshark fields option to only display the username used:

'user@:~$' • tshark -r Cnw2_ftp.pcap -Y "tcp.srcport == $(tshark -r Cnw2_ftp.pcap -Y 'ftp.response.code == 230' -T fields -e tcp.dstport) && ftp.request.command == USER" -T fields -e ftp.request.arg debbie

Which file was downloaded/uploaded from/to the FTP server? (delete as appropriate)

'user@~$' • tshark -r Cnw2_ftp.pcap -Y 'ftp.request.command == RETR' | grep -Po 'RETR \K.*'

Can you reconstruct this file from the Wireshark packet dump? Open the file to verify it's contents are intact.

How many packets have their destination port set to 21?

'user@~$' • tshark -r Cnw2_ftp_bruteforce.pcap -Y 'tcp.dstport == 21' | wc -l

List all packets which have the PUSH bit set. What is the benefit in setting this bit?

'user@~$' • tshark -r Cnw2_ftp_bruteforce.pcap -Y 'tcp.flags.push == 1'

How can you manually calculate the actual port advertised by the PASV/PORT command?

'user@~$' • tshark -r Cnw2_ftp.pcap -Y 'ftp.response.code == 227' | awk -F ',' '{print $5*256+$6}'

How many L4 sessions were created in the FTP session? Note: passive FTP was used in this session.

'user@~$' • tshark -r Cnw2_ftp.pcap -Y 'ftp.response.code == 230 || ftp.response.code == 227' | wc -l

Try to answer these questions with 'cnw2_ftp_bruteforce.pcap: (file)'

How many password guesses were made?

'user@~$' • tshark -r Cnw2_ftp_bruteforce.pcap -Y 'ftp.request.command == PASS' -T fields -e ftp.request.arg | wc -l

Did the attacker finally get in?

'user@~$' • tshark -r Cnw2_ftp_bruteforce.pcap -Y 'ftp.response.code == 230' | grep -q 'Response: 230' && echo YES || echo NO

Which usernames did he/she try?

'user@~$' • tshark -r Cnw2_ftp_bruteforce.pcap -Y 'ftp.request.command == USER' -T fields -e ftp.request.arg | sort -u

2019 oplossingen labo 5 - Lars Lemmens

Met dank aan de Github van Martijn en natuurlijk Lars Lemmens

LABO 5

Encrypting the self created file secret.txt using AES can be done like this: "

'user@:~$' • openssl enc -aes-128-cbc -in secret.txt -out secret.txt.aes

-The enc command is used for symmetric cipher routines

To decrypt the file created above and show the decrypted data on screen, use:

'user@:~$' • openssl enc -d -aes-128-cbc -in secret.txt.aes

To get a list of all available encryption algorithms in OpenSSL, type:

'user@:~$' • openssl list-cipher-commands

On more recent OpenSSL versions the command above will not work. The new syntax is as follows:

'user@:~$' • openssl list -help
'user@:~$' • openssl list -cipher-commands

Thus we need to tell our application that ecrypted_picture.bmp is indeed a bitmap. Bitmaps begin with a 54-byte header.

The idea is to extract the first 54 bytes of the unencrypted bitmap and overwrite the first 54 bytes of the encrypted one with the real header. See the following examples: "

AES in ECB mode

'user@:~$' 1) openssl enc -aes-128-ecb -in slimmerik.bmp -out slimmerik_ECB.bmp
'user@:~$' 2) dd if=slimmerik.bmp of=slimmerik_ECB.bmp bs=1 count=54 conv=notrunc

"We could, of course, automate this: "

'user@:~$' 1) dd if=slimmerik.bmp bs=1 count=54 > slimmerik_ECB.bmp && openssl enc -aes-128-ecb -k pass:t -in slimmerik.bmp | dd bs=1 skip=54 >> slimmerik_ECB.bmp
'user@:~$' 2) dd if=slimmerik.bmp of=slimmerik_ECB.bmp bs=1 count=54 && dd if=slimmerik.bmp bs=1 skip=54 | openssl enc -aes-128-ecb -k pass:t >> slimmerik_ECB.bmp

AES in CBC mode

'user@:~$' 1) openssl enc -aes-128-cbc -in slimmerik.bmp -out slimmerik_CBC.bmp
'user@:~$' 2) dd if=slimmerik.bmp of=slimmerik_CBC.bmp bs=1 count=54 conv=notrunc

ROT13 encryption

'user@:~$' 1) alias rot13="tr '[A-Za-z]' '[N-ZA-Mn-za-m]'"
'user@:~$' 2) cat slimmerik.bmp | rot13 > slimmerik_rot13.bmpw

You need a key pair to be able to use GnuGP. You can generate one with: "

'user@:~$' • gpg --gen-key

After your keypair is created you should immediately generate a revocation certificate for the primary public key using the option --gen-revoke.

If you forget your passphrase or if your private key is compromised or lost, this revocation certificate may be published to notify others that the public key should no longer be used

'user@:~$' • gpg --output revoke.asc --gen-revoke <mykey>

You can use your key pair to encrypt and sign, but without exchanging public keys this is useless. Others need your public key to verify your signatures and to send encrypted messages to you. You need their keys for the same purposes.

'user@:~$' • gpg --list-keys

You can export your public key using:

'user@:~$' • gpg --output <file> --export <email>

Now import some keys from classmates:

'user@:~$' • gpg --import <file>

You already have an automatically created encryption subkey. Now you will create another subkey for signing.

Instead of the master key the subkey will be used to verifying message signatures.

'user@:~$' • gpg --edit-key YOURMASTERKEYID

Exercise 1:

Bob needs to send a text file through an encrypted tunnel to Alice. Both already agreed on a shared secret 'secret' using the Diffie Hellman algorithm. Alice wants to display the contents of the file directly on her screen instead of storing it locally and then opening it. Use a suitable encryption algorithm. The data is sent over a medium which only allows ASCII text.

'Alice@leia:~$' • nc -l 10000 | openssl enc -a -d -aes-128-cbc -k pass:secret
'Bob@laptop:~$' • cat file | openssl enc -a -aes-128-cbc -k pass:secret | nc leia.uclllabs.be 10000

Exercise 2:

Bob needs to send a text file through an encrypted tunnel to Alice. Both already agreed on a shared secret 'secret' using the Diffie Hellman algorithm. Alice wants to display the contents of the file directly on her screen instead of storing it locally and then opening it. Use a suitable encryption algorithm. The data is sent over a medium which only allows ASCII text. "

Step 1:

As Bob needs to send an encrypted file to Alice, he will need her public key.

So in the first step Alice needs to generate a keypair, and export her public key so she could provide it to Bob. "

'Alice@Server ~ $' • gpg --gen-key
'Alice@Server ~ $' • gpg --output alice.gpg --export alice@uclllabs.be

Step 2:

Alice has exported her gpg public key to the file alice.gpg.

She sends this file e.g. by email to bob. Note that this file is no secret, it is just a public key. Now bob can import Alice's public key into gpg: "

'Bob@leia ~ $' • gpg --import alice.gpg

Step 3:

Bob is ready to sent his secret text file to Alice while providing confidentiality:

'Alice@Server ~ $' • nc -l -p 10000 | gpg --decrypt --quiet

'Bob@leia ~ $' • cat file.txt | gpg --encrypt --armor --output - --recipient alice@uclllabs.be | nc -N server.x.cnw2.uclllabs.be 10000

Exercise 3:

Same exercise as above, but now use gpg and netcat to create a simple chat application.

'Alice@Server ~ $' • nc -l -p 10000 | gpg --decrypt --quiet --allow-multiple-messages 

'Bob@leia ~ $' • while read line; do echo $line | gpg --encrypt --armor --output - --recipient alice@uclllabs.be; done | nc -N server.x.cnw2.uclll

2019 oplossingen labo 6 - Lars Lemmens

Met dank aan de Github van Martijn en natuurlijk Lars Lemmens

LABO 6

Check the contents of the ucll.be wildcard certificate, and make sure you understand the chain of trust.

'user@:~$' • echo | openssl s_client -connect ucll.be:443 | openssl x509 -text -noout

We'll start this lab by making our very own SSL certificate. Before we can create a certificate we need to generate an RSA private key.

'user@:~$' • openssl genrsa -aes128 -out TomBola.keys 2048

Use the following command to remove the pass phrase:

'user@:~$' • openssl rsa -in TomBola.keys -out TomBola.keys

Now create the Certificate Signing Request.

'user@:~$' • openssl req -new -key TomBola.keys -out TomBola.csr

Lazy admins will probably prefer the following command, its result is the same as all three commands above combined:

'user@:~$' • openssl req -new -newkey rsa:2048 -keyout TomBola.keys -nodes -out TomBola.csr

This verification step is optional but recommended. Now we need somebody to sign our key. We will use our own private key for the signature, creating a self-signed certificate.

As a self-signed certificate is signed by itself it won't be trusted by client software like email clients and web browsers.

Only public keys of real Certificate Authorities (CA) are included in the browsers or OSs certificate stores.

'user@:~$' • openssl x509 -req -days 365 -in TomBola.csr -signkey TomBola.keys -out TomBola.crt

If somehow you forgot which key/crt/csr files belong to each other, compare their modulus values. They should be the same. To ease the comparing process create a hash value first.

'user@:~$' • openssl x509 -in TomBola.crt -noout -modulus | md5sum; \ openssl req -in TomBola.csr -noout -modulus | md5sum; \ openssl rsa -in TomBola.keys -noout -modulus | md5sum

As we need a Subject Alternative Name (SAN) field to specify additional names associated with our certificate the first step is to create a small openssl configuration file.

FILE: uclllabs_be.conf

[ req ]
default_bits = 4096
prompt = no
encrypt_key = no
default_md = sha512
distinguished_name = dn
req_extensions = v3_req

[ dn ]
C = BE
O = UC Leuven
CN = *.uclllabs.be

[ v3_req ]
subjectAltName = DNS:uclllabs.be

In the next step, we generate our CSR

'user@:~$' • openssl req -new -newkey rsa:4096 -nodes -out star_uclllabs_be.csr -keyout star_uclllabs_be.key -subj "/C=BE/ST=/L=/O=UC Leuven/CN=*.uclllabs.be" -sha512 -config uclllabs_be.cnf
'user@:~$' • openssl req -new -nodes -out star_uclllabs_be.csr -keyout star_uclllabs_be.key -config uclllabs_be.cnf

First check whether the certificate's common name corresponds with the server name, check the expiration date and check the chain of trust.

'user@:~$' • echo | openssl s_client -connect ucll.be:443 | openssl x509 -text -noout | grep -A2 Validity

Second, verify the certificate is not listed on the included CRL (Certificate Revocation List): http://crl3.digicert.com/TERENASSLCA3.crl

'user@:~$' 1) wget http://crl3.digicert.com/TERENASSLCA3.crl
'user@:~$' 2) openssl crl -in TERENASSLCA3.crl -text -noout

Unfortunately, this does no seem to work. OpenSSL stops and spawns an error message

The reason is that TERENA published their CRL in DER format, and by default OpenSSL uses the PEM format. Lets convert the CRL to the correct format and try again:

'user@:~$' 1) openssl crl -inform DER -in TERENASSLCA3.crl -outform PEM -out TERENASSLCA3.crl.pem
'user@:~$' 2) openssl crl -in TERENASSLCA3.crl.pem -text -noout

The last two commands could be combined in one so the conversion from DER to PEM format is not necessary anymore:

'user@:~$' • openssl crl -inform DER -in TERENASSLCA3.crl -text -noout

And without first downloading the crl:

'user@:~$' • wget -q -O - http://crl3.digicert.com/TERENASSLCA3.crl | openssl crl -inform DER -text -noout

And with extracting the CRL URI automatically:

'user@:~$' • wget -q -O - $(echo | openssl s_client -connect ucll.be:443 2>/dev/null | openssl x509 -text -noout | grep -oP 'URI:\K.*\.crl'| head -1) | openssl crl -inform DER -text -noout

Let's find the serial number of our certificate:

'user@:~$' • openssl x509 -in cert.pem -text

shows our certificate and we find the certificate serial number being: "0d:d9:43:24:0a:84:a5:e6:36:94:ff:c7:eb:e8:1e:3f"

Or in one command with:

'user@:~$' • echo | openssl s_client -connect ucll.be:443 2>/dev/null | openssl x509 -text -noout | grep -A1 -i serial

If we would like to verify this serial number manually we need to remove the colons or add colons to the serials in the crt.

Removing should be a peace of cake since the previous labs. Adding a colon every two characters is a bit more complex: "

'user@:~$' • echo 0d:d9:43:24:0a:84:a5:e6:36:94:ff:c7:eb:e8:1e:3f | tr -d ':'
=> OUTPUT: 0dd943240a84a5e63694ffc7ebe81e3f

'user@:~$' • echo 0dd943240a84a5e63694ffc7ebe81e3f | sed 's/..\B/&:/g'
=> OUTPUT: 0d:d9:43:24:0a:84:a5:e6:36:94:ff:c7:eb:e8:1e:3f
'user@:~$' • echo 0dd943240a84a5e63694ffc7ebe81e3f | sed 's/..//'
=> OUTPUT: d943240a84a5e63694ffc7ebe81e3f

'user@:~$' • echo 0dd943240a84a5e63694ffc7ebe81e3f | sed 's/../&/'
=> OUTPUT: 0dd943240a84a5e63694ffc7ebe81e3f

'user@:~$' • echo 0dd943240a84a5e63694ffc7ebe81e3f | sed 's/../&:/'
=> OUTPUT: 0d:d943240a84a5e63694ffc7ebe81e3f

'user@:~$' • echo 0dd943240a84a5e63694ffc7ebe81e3f | sed 's/../&:/g'
=> OUTPUT: 0d:d9:43:24:0a:84:a5:e6:36:94:ff:c7:eb:e8:1e:3f:

'user@:~$' • echo 0dd943240a84a5e63694ffc7ebe81e3f | sed 's/..\B/&:/g'
=> OUTPUT: 0d:d9:43:24:0a:84:a5:e6:36:94:ff:c7:eb:e8:1e:3f

Of course, much easier is to just use the -serial parameter of OpenSSL, it will be displayed in the correct format automatically:

'user@:~$' • openssl x509 -in cert.pem -serial -noout

Of course it is even more easy to just let OpenSSL do all the hard work, just like we do with our web browsers and mailclients. It is the client software which verifies the certificate and not the user.

'user@:~$' • openssl verify -CAfile TERENASSLCA3.crl.pem -crl_check cert.pem cert.pem: C = BE, ST = Vlaams-Brabant, L = Leuven, O = UC Leuven, CN = *.ucll.be

Now its time to do something with our newly created certificate (TomBola.crt). OpenSSL not only includes SSL/TLS client software but also a server, which can act as a very basic web server:

'user@:~$' • openssl s_server -accept 10000 -cert TomBola.crt -key TomBola.key -www -state
'user@:~$' • openssl s_client -connect localhost:10000

Use the private key from your certificate with the following command-line

'user@:~$' • openssl dgst -sha256 -sign TomBola.key -out examenvragen.pdf.sha2 examenvragen.pdf

When you receive the document it's signature can be verified with the following command:

'user@:~$' • openssl dgst -sha256 -verify TomBola.pub -signature examenvragen.pdf.sha2 examenvragen.pdf

Use the following OpenSSL command to extract the public key from the certificate and execute the command above to verify the integrity of the document and also authenticate its sender/creator.

'user@:~$' • openssl x509 -in TomBola.crt -pubkey -noout > TomBola.pub

Use Wireshark to analyze and observe the TLS handshake between your browser and a https site of your choice. Try to answer the following questions:

Which version of the SSL/TLS protocol is used?

Which signature hash algorithms are advertised as supported by your browser?

Which cipher suites are supported by the client (browser), and which are supported by the server?

Which cipher suite is chosen? Explain the different parts of the cipher suite.

Is it the client or the server who defines the cipher suite to be used?

If you need to see the contents of SSL/TLS encrypted packets you need to feed the correct decryption keys into Wireshark.

If you have access to the private key and no Diffie-Hellman is used to calculate the session keys (shared secrets), Wireshark can decrypt all data.

In most cases you do not have access to the private key or DHE is used to calculate the session keys, thus the above option will not work.

Fortunately, some browsers (like firefox) have the ability to save these session keys to a file, allowing Wireshark to decrypt all SSL/TLS data to/from any website:

'user@:~$' 1) export SSLKEYLOGFILE=/home/slimmerik/sslkey.log
'user@:~$' 2) firefox &
'user@:~$' 2) sudo wireshark -o ssl.keylog_file:/home/slimmerik/sslkey.log
# crl 	            Certificate Revocation List (CRL) Management.
# rsa 	            RSA key management (private key).
# csr 	            Certificate Signing Request (CSR) Management.
# x509 	        X.509 Certificate Data Management (public key certificate).
# s_client 	    Openssl SSL/TLS client (e.g. an https client)
# s_server 	    Openssl SSL/TLS server (e.g. an https server)
# enc 	            Encoding with Ciphers (encryption and decription).

Exercise 1:

Take a close look at the contents of cert.pem. It is a pem encoded digital certificate.

With the following OpenSSL magic the certificate can be displayed in a more human-friendly format."

'user@:~$' • openssl x509 -text -noout -in cert.pem

Exercise 2:

Let's say we would like to check the expiration date of the certificate used on https://wiki.uclllabs.be. We could use the following set of commands:"

'user@:~$' • openssl s_client -connect wiki.uclllabs.be:443 > tempfile

Now open the temp file with vim, your preferred text editor and delete all lines before -----BEGIN CERTIFICATE----- and after -----END CERTIFICATE-----.

Next use the command below to find the correct expiration date:

'user@:~$' • openssl x509 -noout -enddate -in tempfile

And if you managed to understand everything this far in this lab, you should be able to glue the above together in just one command line.

'user@:~$' • echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | perl -nle 'print if /BEGIN/../END/' | openssl x509 -noout -enddate
'user@:~$' • echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -noout -enddate

Now with a few additions, the above could be used as a base for a fully automated certificate expiration checker

Create a textfile with all your domains in it for which ssl certificates are used. Of course this could be automated too.

There are of course less ugly ways for achieving the same

'user@:~$' • for foo in $(cat hosts); do if [[ $(echo $(date -d"$(echo | openssl s_client -connect $foo:443 2>/dev/null | openssl x509 -noout -enddate
| cut -d'=' -f2 | awk '{print $2 " " $1 " " $4}')" +%s) - $(date +%s) | bc) -gt 0 ]]; then echo $foo: OK; else echo $foo: EXPIRED;fi;done

And now a shorter version with some more OpenSSL magic

'user@:~$' • for foo in $(cat hosts); do if echo | openssl s_client -connect $foo:443 2>/dev/null 
| openssl x509 -noout -checkend 0; then echo $foo: OK; else echo $foo: EXPIRED; fi;done

And magic++:

'user@:~$' • for foo in $(cat hosts); do check_ssl_cert -H $foo;done

Exercise 3:

Create a oneliner which shows the amount of currently revoked certificates in the Terena SSL CA revocation list.

Do not create temporary files. The CRL can be found at http://crl3.digicert.com/TERENASSLCA3.crl."

'user@:~$' • wget -q -O - http://crl3.digicert.com/TERENASSLCA3.crl | openssl crl -inform DER -text -noout | grep -P '^\s+Serial Number' | wc -l

Exercise 4:

Companies like Google and Microsoft make heavily use of the X.509 subjectAltName extension.

UCLL also uses this extension to add an alternative name *.ucll.be to the common name (ucll.be) of the certificate.

Create a oneliner which calculates the amount of DNS Subject Alternate Names used in the SSL certificate of gmail.com."

'user@:~$' • echo | openssl s_client -connect facebook.com:443 2>/dev/null | openssl x509 -text -noout | grep -o 'DNS:' | wc -l

Exercise 5:

Create a CLI oneliner to find a match between different rsa private key files and their companion crt files. The output should look something like:

alfa.key matches beta.crt
gamma.key matches delta.crt

First we need to generate some certificates so we can actually verify our solution. The following command creates a self-signed certificate in one step:

'user@:~$' • openssl req -x509 -sha256 -newkey rsa:2048 -keyout tombola_uclllabs_be.key -out tombola_uclllabs_be.crt -days 365 -nodes -subj 
"/C=BE/ST=/L=/O=UC Leuven/CN=tombola.uclllabs.be"

With the following for loop we can easily generate a few certificates to test with:

'user@:~$' • for foo in TomBola GreetSchap VanderNeffe LukRaak AlainProvist; do openssl req -x509 -sha256 -newkey rsa:2048 -keyout 
"$foo"_uclllabs_be.key -out "$foo"_uclllabs_be.crt -days 1024 -nodes -subj

As explained in this lab, the modulus of corresponding files (CSR, private KEY and Certificate) should be the same. We'll create a oneliner which tests wich files belong to one another. I.e. which files have the same modulus.

'user@:~$' • for key in $(ls -1 *.key); do for crt in $(ls -1 *.crt); do if [[ $(openssl rsa -in $key -noout -modulus | md5sum) == $(openssl x509 -in $crt -noout -modulus | md5sum) ]]; then echo $key matches $crt;fi ;done;done

Or a slightly shorter version:

'user@:~$' • for key in $(ls *.key); do for cert in $(ls *.pem); do [[ $(openssl rsa -in $key -noout -modulus | md5sum) == $(openssl x509 -in $cert -noout -modulus | md5sum) ]] && echo $key matches to $cert;done;done

Exercise 6:

Create a CLI oneliner using openssl to retrieve the certificate of the server wiki.uclllabs.be and to encrypt the text

'Lets make CNW2 great again'" with it’s public key. In the first step, we willll connect to https://wiki.uclllabs.be and extract the public key from the presented certificate:"

'user@:~$' • echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -noout -pubkey > public.pem

Now the public key is saved in a tempfile we can use it to encrypt arbitrary data.

'user@:~$' • echo "Let's make CNW2 great again" | openssl rsautl -encrypt -pubin -inkey public.pem -out CNW2.encrypted

Or without first downloading the public key:

'user@:~$' • echo "Let's make CNW2 great again" | openssl rsautl -encrypt -pubin -inkey <(echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -noout -pubkey) -out CNW2.encrypted

Exercise 7:

Experiment with the tools sslyze and nmap to enumerate supported ssl cipher suites for various websites. Make sure you understand its output. See the folloing example:

- sslyze --regular --http_headers wiki.uclllabs.be
- nmap --script ssl-enum-ciphers -p 443 wiki.uclllabs.be

Exercise 8:

Let’s Encrypt has rate limits which prevent issuing more than 20 new certificates per domain per week. They use the public suffix list for this.

The limit is per registered domain, not per subdomain. So all student certificates count for the same uclllabs.be suffix.

"root #" • certbot --apache -d "tom.x.cnw2.uclllabs.be, bola.x.cnw2.uclllabs.be, tom.bola.x.cnw2.uclllabs.be"

Exercise 9:

Create a CLI oneliner using OpenSSL to retrieve the certificate of the server wiki.uclllabs.be and to display only its fingerprint, serial and public key. Sample output:"

'user@:~$' • echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -noout -fingerprint -serial -pubkey

2019 oplossingen labo tussentest - Lars Lemmens

Met dank aan de Github van Martijn en natuurlijk Lars Lemmens

LABO TEST

Exercise 1:

Copy the content of your it-enabled grandmothers id_rsa.pub file in your ~/.ssh/authorized_keys file"

'user@:~$' • ssh user@leia.uclllabs.be -p 22345 -i "/path/to/your grandmothers identity_file"
'user@:~$' • ssh user@leia.uclllabs.be -p 22345

Exercise 2:

Try to find out which TCP ports are open on leia without using tools like netstat or ss. Execute on leia for increased speed.

'user@:~$' • nc -zv -w 1 leia.uclllabs.be 1-65535 2>&1 | grep succeeded | awk '{print $4}'

'user@:~$' • for foo in {1..65535}; do nc -N -w1 leia.uclllabs.be $foo </dev/  null >/dev/null && echo $foo;done

'user@:~$' • nmap -p 1-65535 leia.uclllabs.be | grep -P '\d+/tcp.*open' |cut -d'/' -f1

'user@:~$' • nmap --reason -p 1-65535 leia.uclllabs.be | grep -oP '\d+(?=/tcp.*open)'

Exercise 3:

Create a oneliner which lists all palindromes with exactly 6 letters in a dictionary.

'user@:~$' • cat dutch | grep -P '^(.)(.)(.)\3\2\1$'

Exercise 4:

As a web server administrator you have been asked to give your manager a Linux CLI oneliner to extract the 5 IP addresses that contacted the web server the most

The apache log is located in /home/logs. Create a correct oneliner. The output should look something like this: (count IPs)

'user@:~$' • cat apache_google.log | cut -d ' ' -f1 | sort | uniq -c | sort -rn | head -5

Exercise 5:

What Linux ssh command do you use to bind your local port 3000 to a web server on port 4444 on the network of the ssh server

'user@:~$' • ssh -p 22345 username@leia.uclllabs.be -L 3000:IP_web_server:4444

Exercise 6:

Create an apache vhost (netcat.X.cnw2.uclllabs.be) which displays a single web page (index.html). How can you update/alter this website (index.html) via a Netcat connection from your laptop."

'root@myserver' 1)  mkdir /var/www/html/netcat
'root@myserver' 2)  nano netcat.conf
<VirtualHost *:80>
    ServerAdmin root@netcat.X.cnw2.uclllabs.be
    ServerName netcat.X.cnw2.uclllabs.be
    DocumentRoot /var/www/html/netcat

    LogLevel info
    ErrorLog ${APACHE_LOG_DIR}/netcat-error.log
    CustomLog ${APACHE_LOG_DIR}/netcat-access.log combined
</VirtualHost>

'# root@myserver' 1)  a2ensite netcat
'# root@myserver' 2)  systemctl reload apache2
'# root@myserver' 3)  nc -l -p 10000 >> /var/www/html/netcat/index.html
'user@laptop:~$'  4)  echo test | nc netcat.X.cnw2.uclllabs.be 10000

Exercise 7:

On server Leia, use the list of logged in users to print only the username that has been logged in to the server for the longest time

'user@:~$' • who | awk '{print $3$4 " " $1}' | sort -n | awk '{print $2}' | head -1

Exercise 8:

Some subdirectory of /tmp contains a bunch of movies. However, their extension is wrong.

The extension should be .avi instead of .jpg. Copy these files to your homedirectory and correct their extensions in one line. "

'user@:~$' • ls -1 *.jpg | while read foo; do echo cp $foo ~/$(basename $foo .jpg).avi;done
'user@:~$' • ls -1 *.jpg | while read foo; do echo cp $foo ~/${foo%.jpg}.avi;done

Exercise 9:

Create a Linux CLI oneliner to decode the following string 'SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSBmb3VuZCB0aGUgY29ycmVjdCBhbnN3ZXIK'

'user@:~$' • echo 'SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSBmb3VuZCB0aGUgY29ycmVjdCBhbnN3ZXIK' | openssl enc -a -d

'user@:~$' • echo 'SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSBmb3VuZCB0aGUgY29ycmVjdCBhbnN3ZXIK' | base64 -d

Exercise 10:

Create a regular expression to match all words in a dictionary with 5 unique letters. "

'user@:~$' • cat /usr/share/dict/dutch | grep -P '^[a-zA-Z]{5}$'| grep -vP '(.).*\1'

Exercise 11:

Create a oneliner to show ‘Time = 15:44:25 (11/10/1901)' or 'Time = 15:44:25 (11-10-1901)’ each time with the current time and date.

'user@:~$' • echo "Time = $(date '+%X (%x)')"
'user@:~$' • date '+Time = %X (%x)'
'user@:~$' • date '+Time = %X (%Y/%d/%m)'

Exercise 12:

Create a oneliner which lists the top 3 most used passwords in the ftp brute force attack captured in "ftp_bruteforce.pcap". Use a suitable sniffer filter which only displays whats really needed.

'user@:~$' • tshark -r ftp_bruteforce.pcap -Y 'ftp.request.command==PASS' -T fields -e 'ftp.request.arg' 2>/dev/null| sort | uniq -c | sort -rn | head -3

2019 oplossingen Testexamen - Lars Lemmens

Met dank aan de Github van Martijn en natuurlijk Lars Lemmens

Exercise 1

Create a CLI oneliner to match all words with 14, 15 or 16 unique letters. The output shouldlook like:

Words with 14 letters: EHBO-diploma's bruiloftsdagen katrolschijven verontschuldig ...
Words with 15 letters: dampkringslucht sandwichformule ...
Words with 16 letters: ...

'user@:~$' • for foo in 14 15 16; do echo "Words with $foo letters:" $(grep -vP '(.).*\1' /usr/ share/dict/dutch | grep -P "^.{$foo}$");done

Exercise 2

Create a linux CLI oneliner to extract an overview of the different FTP usernames in the file ftp_bruteforce.pcap. Only the commands tshark and sort are allowed.

'user@:~$' • tshark -r ftp_bruteforce.pcap -Y 'ftp.request.command == USER' -T fields -e ftp.request.arg |sort -u

Exercise 3

Create a oneliner to show ‘Time = 15:44:25 (11/10/1901)' or 'Time = 15:44:25 (11-10-1901)’ each time with the current time and date.

'user@:~$' • date '+Time = %X (%x)'

Exercise 4

Create a linux CLI oneliner to decode the following string ‘RGUgcHVudGVuIG9wIGRlemUgdnJhYWcgemlqbiBhbCBiaW5uZW4uCg==’. (/home/logs/secret)

'user@:~$' • cat /home/logs/secret | openssl enc -a -d

Exercise 5

Create a CLI oneliner using openssl to retrieve the certificate of the server wiki.uclllabs.beand to display only it’s fingerprint, serial and public key.Sample output:

SHA1 Fingerprint=8C:CB:D9:A1:F3:3C:78:C2:2E:F6:EB:1C:CD:4B:F3:39:1B:9A:EE:4Eserial=0966DB4115B74092EE07D6DA585547D8-----BEGIN PUBLIC KEY-----MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2NHdNb3iWbb7mx9UFYzbv05YvUe+uBD8IunSnpj4SSol+5RG5EKZhFAcXwH9FCUxXE7ZZP3FDLNG0qG8cLSHjg==-----END PUBLIC KEY-----

'user@:~$' • echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -noout -fingerprint -serial -pubkey

2019 samenvatting - Lars Lemmens

Met dank aan de Github van Martijn en Lars Lemmens

Hoofdstuk 2

2.1 Principes van netwerkapplicaties

2.1.1 Structuren van netwerkapplicaties

Client-server structuur

P2P-structuur

2.1.2 Communicerende processen

Client – en serverprocessen

Interface tussen proces en computernetwerk

Adresseren van processen

2.1.3 Transportdiensten voor applicaties

| Data Integriteit:

Timing:

Diensten van TCP & UDP

 

68747470733a2f2f65787465726e616c2d636f6e74656e742e6475636b6475636b676f2e636f6d2f69752f3f753d6874747073253341253246253246692e726564642e6974253246716b30716171666135786d32312e6a706726663d31266e6

Beveiligen van TCP

TCP gebruikt SSL/TLS → TCP met SSL/TLS → doet niet alleen wat oorspronkelijke TCP doet → levert ook beveiliginsdiensten voor communicerende processen → SSL niet een 3e transportprotocol voor internet is dat op zelfde niveau werkt als UDP & TCP → uitbreiding van TCP → uitbreidingen geimplementeerd in applicatielaag

Diensten die niet geleverd worden door internettransportprotocollen

2.1.5 Protocollen voor applicatielaag

In applicatielaag volgende aspecten gedefinieerd:

2.1.6 Netwerkapplicaties die in dit boek beschreven worden

2.2 Web & HTTP

2.2.1 Meer over HTTP

68747470733a2f2f65787465726e616c2d636f6e74656e742e6475636b6475636b676f2e636f6d2f69752f3f753d687474702533412532462532467777772e63656c6c62696f6c2e636f6d25324662696f696e666f726d61746963735f77656

2.2.2 Non-persistente en persistente verbindingen

Non persistent

Basis HTML-file met volgende url: http://www.someschool.edu/someDepartment/home.index

  1. HTTP-client starts TCP-verbinding met server → client & server gebruiken socket
  2. HTTP-client verzendt HTTP-verzoekbericht naar HTTP
  3. HTTP-serverproces ontvangt verzoekbericht
  4. HTTP-serverproces TCP opdracht → verbreek verbinding als bericht ontvangen
  5. HTTP-client ontvangt antwoordbericht
  6. Herhaal stap 1-4 voor elk object

RTT → tijd die packet nodig heeft → client naar server & omgekeerd

Klikt op een hyperlink → 3-way handshakeproces nodig:

  1. Client verzendt TCP-segment naar server

  2. Server bevestigt & antwoord met TCP-segment

  3. Client verzendt 2e bevestiging naar server

    → 1 RTT

Persistent

2.2.3 Indeling HTTP-berichten

HTTP-verzoekbericht

HTTP-antwoordbericht

68747470733a2f2f65787465726e616c2d636f6e74656e742e6475636b6475636b676f2e636f6d2f69752f3f753d68747470732533412532462532467777772e7265736561726368676174652e6e657425324670726f66696c652532464d6f7

2.2.4 Interactie gebruikers & servers: cookies

  1. Cookieheaderregel in HTTP-antwoordbericht
  2. Cookieheaderregel in HTTP-verzoekbericht
  3. Cookiebestand opgeslagen op host gebruiker & browser van gebruiker beheerd
  4. Back-enddatabase op website

2.2.5 Webcaching

Netwerkentiteit die HTTP-verzoeken afhandelt names oorspronkelijke webserver waar verzoek oorspronkelijk naartoe is gestuurd

Browser object http://www.someschool.edu/campus.gif

  1. Browser start TCP-verbinding met webcache & verzendt HTTP-verzoek voor object naar webcache
  2. Webcache checks → exemplaar opgevraagde object aanwezig? → if yes → webcache verzendt object in HTTP-antwoordbericht naar browser client
  3. Opgevraagde object niet op webcache → TCP-verbinding met oorspronkelijke server → webcache verzendt HTTP-verzoek voor object via TCP-verbinding → wanneer server ontvangen → verzendt object in HTTP-antwoordbericht naar webcache
  4. Opslaan kopie lokaal & stuurt een exemplaar naar browser

2 redenen webcaching

CDN (Content Distribution Networks) → veel geografische verspreide cachegeheugens in internet → groot deel dataverkeer lokaal

2.2.6 The conditional GET

  1. Client maakt get request
  2. Server reageert met header
  3. Client checkt de Last-Modified header
  4. ls Last nieuwer is dan cache → haal pagina opnieuw op & zet opnieuw in cache
  5. anders → laad van cache
GET /index.html HTTP/1.1\r\n
Host: www-net.cs.umass.edu\r\n
User-Agent: Firefox/3.6.10\r\n
Accept: text/html,application/xhtml+xml\r\n
Accept-Language: en-us,en;q=0.5\r\n
Accept-Encoding: gzip,deflate\r\n
Accept-Charset: ISO-8859-1,utf-8;q=0.7\r\n
Keep-Alive: 115\r\n
Connection: keep-alive\r\n
\r\n

HTTP/2

Goal: vertraging verlagen in multi-object HTTP requests HTTP1.1** :** meerdere, pipelined GETs over 1 TCP connectie

HTTP/2** :** flexibiliteit verhogen server in versturen van objects naar client Goal: vertraging verlagen in multi-object HTTP requests

68747470733a2f2f65787465726e616c2d636f6e74656e742e6475636b6475636b676f2e636f6d2f69752f3f753d68747470732533412532462532466d69726f2e6d656469756d2e636f6d2532466d617825324631363430253246302a6e684

HTTP/2 to HTTP/3

Goal: vertraging verlagen in multi-object HTTP requests

HTTP/2 over single TCP connectie wil zeggen:

2.3 E-mail op het internet

2.3.1 SMTP

Werking:

  1. Alice → UA opdracht verstuur bericht
  2. Alice's UA stuurt bericht mailserver→ in berichtenwachtrij
  3. Clientzijde van SMTP opent TCP-verbinding met Bob's e-mailserver
  4. SMTP-client verzendt het bericht van Alice via de TCP-verbinding
  5. Bob's mailserver plaatst het bericht in Bob's mailbox
  6. Bob roept zijn user agent aan om bericht te lezen

68747470733a2f2f65787465726e616c2d636f6e74656e742e6475636b6475636b676f2e636f6d2f69752f3f753d687474702533412532462532467777772e61667465726e6572642e636f6d253246626c6f6725324677702d636f6e74656e7

2.3.2 Vergelijking met HTTP

SMTP

HTTP

2.3.3 Formats e-mailberichten

2.3.4 Mail accessprotocollen

SMTP: levering/opslag van e-mailberichten op de server van de ontvanger

Mail Access Protocol: Ophalen server

IMAP: Internet Mail Access Protocol [RFC 3501]: berichten opgeslagen op de server, IMAP biedt ophalen, verwijderen, mappen met opgeslagen berichten op de server

HTTP: Gmail, Hotmail, Yahoo! Mail, etc. biedt webgebaseerde interface bovenop STMP (om te verzenden), IMAP (of POP) om e-mailberichten op te halen

POP3

UA → TCP-verbinding naar mailserver

  1. Autorisatiefase: UA → verstuurt username & password → identitetit gebruiker vaststellen
  2. Transactiefase: UA haalt berichten op
  3. Updatefase: client opdracht quit → POP3-sessie closed

IMAP

Webmail

Ontvanger wil mailbox bekijken → bericht van mailserver naar browser van gebruiker verzonden → behulp van HTTP-protocol

2.4 DNS

2.4.1 Diensten van DNS

DNS verzorgt aantal andere diensten naast vertalen hostnamen in IP-adressen:

(Een MX-record (Mail eXchange-record) is een gegevenstype in het Domain Name System (DNS). Het specificeert de mail server die e-mailverkeer voor het betreffende domein afhandelt. Een domein kan meerdere MX-records hebben met een verschillende prioriteit waardoor het mogelijk is om bijvoorbeeld een back-up mailserver aan te geven als de computer met de hogere prioriteit niet bereikbaar blijkt. De naam die in het MX-record wordt gevonden kan via DNS op zijn beurt in een ip-adres worden vertaald. Src: Wikipedia)

2.4.2 Overzicht van de werking van het DNS

Gecentraliseerd ontwerp levert volgende problemen op:

Een gedistribueerde, hiërarchische database

DNS-caching

DNS-server → in verzoekberichtenketen → wanneer DNS-antwoord ontvangt → verwijzing in lokale cachegeheugen plaatsen

2.4.3 DNS-records en -berichten

DNS-servers bevatten bronrecords → (Naam, Waarde, Type, TTL)

  1. If Type = A then naam bevat hostnaam en Waarde bevat IP-adres van hostnaam
  2. If Type = NS then naam bevat domeinnaam en Waarde bevat hostnaam van authoritative DNS-server die de hostnaam en IP combinaties voor de hosts in dat domein weet
  3. If Type = CNAME then waarde is canonieke hostname voor aliashostname
  4. IF Type = MX then waarde is canonieke naam van mailserver met alias hostname name

Een authoritative DNS-server bevat een A-record

Een niet-authoritative DNS-server bevat een NS-record voor het domein waarin de DNS-server zich bevindt en ook een A-record met het IP-adres van de DNS-server die in het veld Waarde van het NS-record staat

DNS-berichten

  1. Eerste veld is een uniek 16 bit getal waarmee het verzoek geïdentificeerd kan worden. Dat getal word gekopieerd in het antwoordbericht, zodat de client het antwoord en het verzoek kan kopellen
  2. Vlaggen veld bevat een aantal vlaggen. Een 1-bit verzoek/antwoord-vlag (verzoek = 1 en antwoord = 0), 1-bit authoritative-vlag wordt in een antwoordbericht gezet als de DNS-server de authoritative DNS-server voor de hostnaam is, 1-bit recursienoodzaak-vlag wordt gebruikt als de client vraagt om recursief te werken als het gevraagde record niet op die DNS-server staat en een 1-bit recursiemogelijkheids-vlag die in het antwoordbericht staat na een verzoekbericht met een recursienoodzaak-vlag
  1. Bevat een naamveld met de naam waarvoor het IP-adres wordt gezocht
  2. Bevat een typeveld met het type verzoek (Type A, Type NS…)

 

DNS-Security

DDOS-attack:

TLD servers bombarderen:

Aanvallen omleiden

DNS voor DdoS exploiteren

Laatste 2 vormen DNSSEC

2.5 Peer-to-peer bestandsdistributie

P2P file distributie: BitTorrent

Peer neemt deel aan torrent → meldt bij tracker → peer informeert tracker met regelmaat of nog aanwezig in torrent → nieuwe peer → tracker random # peers → verzendt IP-adressen van # peers → naar nieuwe peer → proberen TCP-verbinding met peers op lijst → bepaald tijdstip → elke peer → # chunks bestand → verschillende peers → verschillende verzamelingen chunks hebben → na een bepaalde tijd → gebruiker vraagt elke peer om lijst met chunks die ze hebben → gebruiker vraagt de "missing chunks" van de peerst → zeldzaamste eerst of Rarest first

Tit-for-tat principe:

Gebruiker stuurt chunks naar die vier peers die momenteel haar chunks in het hoogste tempo verzenden → andere peers gestikt door gebruiker (ontvangen geen chunks van gebruiker) → herbeoordeeld top 4 elke 10 seconden

Elke 30 seconden → selecteert willekeurig een andere peers, begint met verzenden van chunks → optimistisch unchocked deze peer → nieuwe gekozen peer kan lid worden van top 4

2.6 Videostreaming en content distribution networks

Internetvideo

2.6.1.1 Streaming stored video

Simpel Scenario:

Hoofddoelen:

2.6.1.2 Streaming stored video : challenges

Continuous playout constraint → zodra play-out van client begint → afspelen overeenkomen met oorspronkelijke timing → maar network delays variabel (jitter) → heeft buffer aan clientzijde nodig om aan play-out vereisten te voldoen

Andere challenges

Client interactiviteit → pause, voortspoelen, terugspelen, verder in video gaan → video packets loss mogelijk → opnieuw verzonden

HTTP-streaming en DASH

D ynamic A daptive S treaming over H TTP

STREAMING VIDEO = CODERING + DASH + PLAYOUT BUFFERING

Content Distribution Networks (CDNs)

Challenge: Hoe content streamen naar 100 tot 1000'en gebruikers tegelijk

Hoofdstuk 8: Security in computer networks

8.1 Wat is netwerkbeveiliging

  1. Vertrouwelijkheid : Alleen zender & beoogde ontvanger inhoud van verzonden bericht begrijpen
  2. Berichtintegriteit : de afzender en ontvanger zeker zijn dat inhoud van communicatie niet wordt gewijzigd
  3. Authenticatie op eindpunt: zender & ontvanger identiteit andere partij vaststellen zeker te zijn dat ander is wie hij beweert
  4. Operationele beveiliging: bijna alle organisaties hebben netwerken aangesloten op het openbare internet.Deze netwerken kunnen daarom mogelijk worden aangetast.

8.2 Principes van cryptografie

Verzender ( X ) verstuurt bericht naar ontvanger (Y)

  1. X gebruikt sleutel K** A**→ invoer versleutelalgoritme
  2. Versleutelalgoritme gebruikt sleutel → onversleutelde bericht m → versleutelde tekst → K** A****(m)**
  3. KA onderling afspreken
  4. Y ook sleutel K** B **** →**invoer onsleutelalgoritme → versleutelde bericht X → plaintext
  5. Y ontvangen versleutelde bericht KA(m) → ontsleutelen → berekenen van Kb(Ka(m)) = m

8.2.1 Cryptografie met symmetrische sleutels

  1. First → Caeser cipher → elke letter in platte tekst → letter → k-letters in alfabet te vervangen
  2. Daarna → monoalfabetisch cijfer → lettervervanging maar moet uniek zijn

Bruteforce-benadering→ uitproberen alle 10^26 → teveel werk

Polyalfabetische codering → verschillende monoalfabetische ciphers gebruikt → afwisselend ingezet → bepaalde positie in onversleutelde bericht te versleutelen

Block ciphers (DES = data encryption standard, 3DES, AES= advanced encryption standard)

2 categorieën van symmetrische versleuteltechnieken

Blockciphers

  1. versleutelen bericht → verwerkt blokken k bits
  2. IF k = 64 → bericht opgesplitst in 64 blokken → elk blok onafhankelijk versleuteld
  3. Codering 1 op 1 toewijzing om k-bit blok cleartext toe te wijzen aan k-bit blok Ciphertext

Hoeveel mogelijke verwijzingen?

Zeer moeilijk uit te voeren. Voor k = 64 moeten Alice en Bob een tabel onderhouden met 2^64 invoerwaarden → onmogelijk → blokcoderingen meestal functies die willekeurig gepermuteerde tabellen simuleren.

Cipher-block chaining (CBC)

Blockcipher → twee of meer blokken identiek zijn→aanvaller mogelijk cleartext raden en misschien het hele bericht decoderen. → solution → willekeur in ciphertext

Werkwijze:

  1. voor bericht versleutelt → genereert Afzender een willekeurige k-bit string,initialisatievector (IV) = c(0) genoemd→ afzender stuurt IV naar ontvanger in leesbare vorm
  2. Eerste blok berekent de afzender m(1) + c(0) → exclusieve OR van eerste blok onversleutelde tekst & IV. → verzender verwerkt met BC → bijhorende blok als versleutelde tekst c(1)=Ks(m(1)+c(0) → verzender versleutelde blok (c1) naar ontvanger
  3. Voor het i-blok genereert de afzender c(i) = Ks(m(i) + c(i-1))

8.2.2 Cryptografie met openbare sleutel

Diffie-Hellman key exchange

  1. Alice haalt Bob's publieke sleutel
  2. Alice versleutelt bericht (m) aan Bob → door public key van Bob en bekend encryptie-algoritme K+B(m).
  3. Bob ontvangt → gecodeerde bericht van Alice → gebruikt private key & bekend decoderingsalgoritme → gecodeerde bericht decoderen
  4. Bob berekent K-B( K+B(m)).
  5. Berekenen van Kb-(Kb+(m)) resulteert in m

Note : each party generates a public/private key pair and distributes the public key. After obtaining an authentic copy of each other's public keys, Alice and Bob can compute a shared secret offline. The shared secret can be used, for instance, as the key for a symmetric cipher.

68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f7468756d622f342f34632f5075626c69635f6b65795f7368617265645f7365637265742e7376672f32353070782d50756

RSA

Maken van publieke en private RSA keys:

  1. Kies 2 grote priemgetallen p & q → hoe groter de waarden hoe moeilijker RSA-algoritme te kraken
  2. Bereken n = p * q
  3. Bereken z = (p – 1) * (q-1)
  4. Kies nummer e, dat kleiner is dan n & geen factoren (buiten 1 ) gemeenschappelijk heeft met z
  5. Zoek een getal d, zodanig dat ed – 1 precies deelbaar is door z. Wij kiezen d zodanig dat e*d mod z = 1
  6. Openbare sleutel (K+B) is het paar van de getallen (n, e)
  7. The private key(K-B) is the pair of the numbers (n, d)

NOTE: Diffie-Hellman niet zo veelzijdig als RSA omdat het niet gebruikt kan worden om berichten met willekeurige lengte te coderen → toegepast om symmetrische sessiesleutel tot stand te brengen → daarna coderen berichten

Berichtintegriteit en digitale handtekeningen

8.3.1 Cryptografische hashfuncties

H(x) = H(Y)

8.3.2 Berichtauthenticatiecode

berichtintegriteit uit te voeren→Alice en Bob→ naast gebruik van cryptografische hashfuncties, → gedeeld geheim nodig→niets meer dan een reeks bits = verificatiesleutel.→ door gedeelde geheim kan berichtintegriteit als volgt worden uitgevoerd:

8.3.3 Digitale handtekeningen

Certificering van openbare sleutels

Certificate authority → echtheid identiteiten authenticeert & certificaten uitgeeft

  1. Een certification authority controleert of een entiteit is wie het zegt dat het is.

  2. certificeringsinstantie identiteit van entiteit verifieert, maakt certificeringsinstantie een certificaat → openbare sleutel van de entiteit aan de identiteit bindt → certificaat bevat openbare sleutel + wereldwijd unieke identificerende informatie over eigenaar van openbare sleutel. Het certificaat digitaal ondertekend door certification authority.

Authenticatie op het eindpunt

Eindpuntverificatie →proces waarbij de ene entiteit zijn identiteit aan een andere entiteit bewijst via een computernetwerk.

8.4.1 Authenticatieprotocol ap1.0

Trudy (indringer) stuurt bericht naar Bob → zegt "ik ben Alice" → Bob weet niet of het werkelijk Alice is 8.4.2 Authenticatieprotocol ap2.0 Alice bekend netwerkadres waaruit ze altijd communiceert→ Bob proberen Alice te verifiëren → bronadres IP-datagram met verificatiebericht overeenkomt met het bekende adres van Alice.

niet moeilijk om IP-datagram te maken, zet elk IP-bronadres dat we willen in het IP-datagram.

8.4.3 Authenticatieprotocol ap3.0

Het wachtwoord is een gedeeld geheim tussen de authenticator en de persoon die wordt geverifieerd.

8.4.4 Authenticatieprotocol ap3.1

Door het wachtwoord te versleutelen→voorkomen Trudy Alice's wachtwoord leert→aannemen dat Alice en Bob een symmetrische geheime sleutel delen, KA – B,dan kan Alice het wachtwoord versleutelen en haar identificatiebericht en het gecodeerde wachtwoord naar Bob sturen. Bob decodeert vervolgens het wachtwoord en verifieert Alice.

De fout: the playback attack : Trudy hoeft alleen maar de communicatie van Alice af te luisteren, de gecodeerde versie van het wachtwoord op te nemen en de gecodeerde versie van het wachtwoord af te spelen naar Bob om te doen alsof ze Alice is.

8.4.5 Authenticatieprotocol ap4.0

Een nonce is een getal dat een protocol maar één keer in een leven zal gebruiken. Dat wil zeggen dat zodra een protocol een nonce gebruikt, het het nummer nooit meer zal gebruiken. Onze ap4.0 gebruikt een nonce in als volgt:

  1. Alice verzendt bericht 'ik ben Alice' aan Bob
  2. Bob kiest een nonce en verzendt die naar Alice
  3. Alice versleutelt de nonce met de symmetrische sleutel van Alice en Bob, KA– B,en stuurt de gecodeerde nonce KA_B(R) terug naar Bob.
  4. Bob ontsleutelt het ontvangen bericht. Als de gedecodeerde nonce gelijk is aan de nonce die hij Alice stuurt, dan is Alice geauthenticeerd

8.5 E-mail beveiligen

8.5.1 Ontwerp van veilige e-mail

Vertrouwelijkheid (Systeem 1)

  1. Gebruikt geheime sleutel Kb-→ verkrijgen symmetrische sleutem Ks
  2. Symmetrische sleutel Ks → ontsleutelen bericht

Sessie key = inefficient

1. Berichtintegriteit

The 2 combined:

8.5.2 PGP

PGP-software gebruikt:

Als PGP installed:

  1. Openbaar sleutelpaar voor gebruiker
  2. Openbare sleutel → website gebruiker of openbare sleutelserver

PGP → mogelijkheid bericht digitaal ondertekenen

8.6 TCP-verbindingen beveiligen

Noodzaak SSL:

SSL lost problemen op door volgende bovenop TCP uit te voeren:

  1. Vertrouwelijkheid
  2. Gegevensintegriteit
  3. Serverauthenticatie
  4. Clientauthenticatie

SSL → eenvoudige API vergelijkbaar API van TCP

8.6.1 Het hele verhaal, maar vereenvoudigd

Fase 1: Handshake

  1. Bob TCP-verbinding met Alice maken
  2. Verzekeren dat Alice echt Alice is
  3. Alice geheime mastersleutel zenden → Alice & Bob gebruiken → symmetrische sleutel genereren → nodig voor SSL

Fase 2: Verkrijgen van een sleutel

Alice & Bob moeten MS gebruiken om vier sleutels te genereren:

Fase 3: Gegevensoverdracht

Geen goed idee → integriteit alle gegevens tijdens hele sessie dat Bob gestuurd heeft controleren

  1. SSL splitst gegevensstream → records
  2. SSL voegt berichtauthenticatiecode toe aan elk record → versleutelt combinatie
  3. Maken van berichtauthenticatiecode → Bob hashfunctie toe → combinatie recordgegevens & sleutel Mb
  4. Versleutelen → Bob gebruikt sessievercijfersleutel Eb

Man in the middle attack ( MITM) : kansegmenten in de TCP-stream vervangen, invoegen en verwijderen tussen Alice en Bob.

Aannemen dat elk TCP-segment exact 1 record verpakt is → kijken hoe Alice segmenten verwerkt

  1. TCP in host Alice → denkt alles is OK → 2 records aan SSL-sublaag
  2. SSL in host Alice → 2 records ontsleutelen
  3. SSL in host Alice →berichtauthenticatiecode in elk record gebruiken → integriteit van gegevens in 2 records
  4. SSL → ontsleutelde bytestream van 2 records doorgeven → applicatielaag → door Alice ontvangen bytestream → gevolg verwisseling records → niet in juiste volgorde

Oplossing: gebruik volgnummers.

  1. Bob onderhoudt een reeksnummerteller, die begint bij nul en wordt verhoogd voor elke SSL-record die hij verzendt.
  2. Wanneer hij de MAC berekent,neemt hij het volgnummer op in de MAC-berekening.

Zo is MAC = hash van gegevens + MAC-toets + huidig volgnummer.

Alice kan Bob's volgnummers opsporen, zodat ze de gegevensintegriteit kan verifiëren.

SSL record

Bestaat uit → typeveld, versieveld, lengteveld, gegevensveld & berichtauthenticatiecode

8.6.2 Het hele verhaal, maar wat minder vereenvoudigd

SSL handshake

Alice & Bob begin SSL-sessie zelf afspraken maken over cryptografische algoritmen → aka handshakeprocedurefase → + Alice & Bob zenden elkaar nonces toe → gebruikt bij maken van sessiesleutels (EB,MB,EA,MA)

Handshakeprocedure bij SSL:

  1. Client verzendt lijst → versleutelalgoritmen die hij ondersteunt & zelfgekozen nonce
  2. Server kiest uit ontvangen lijst algoritme voor → symmetrische sleutel, openbare sleutel & berichtauthenticatiecode → server verstuurt bericht met voorkeuren, certificaat & zelfgekozen nonce
  3. Client authenticeert certificaat + berekent openbare sleutel server + genereert geheime pre-mastersleutel (PMS) → versleutelt PMS met openbare sleutel server → verzendt versleutelde PMS naar server
  4. Afgesproken functie bepalen sleutel → berekenen client & server onafhankelijk → geheime mastersleutel met PMS & nonces → geheime mastersleutel in stukken gehakt → 2 coderingssleutels & 2 berichtauthenticatiecodes genereren → gekozen symmetrische codering werkt met cipher-block-chaining → 2 initialisatievectoren gemaakt → geheime mastersleutel → daarna alle berichten versleuteld & geauthenticeerd
  5. Client verzendt berichtauthenticatiecode → alle handshakeprocedureberichten
  6. Server verzendt berichtauthenticatiecode → alle handshakeprocedureberichten

Alleen nonces → niet mogelijk "replay attack" te voorkomen

Verbinding verbreken

Iemand geeft in het typeveld aan of de record dient om de SSL-sessie te beëindigen. Door zo'n veld op te nemen, zou Alice weten dat als ze een TCP FIN zou ontvangen voordat ze een SSL-sluitingsrecord zou ontvangen, ze weet dat er iets grappigs aan de hand is.

8.7 Beveiliging op netwerklaag: IPsec & VPN

8.7.1 IPsec & VPN

Met VPN → interne dataverkeer van de instelling verzonden via het publiekelijk toegankelijke internet in plaats van via een fysiek gescheiden netwerk. → dataverkeer eerst versleuteld

CHECK PAGINA 597 IN HANDBOEK VOOR AFBEELDING

8.7.2 Authentication header-protocol en het encapsulation security payload-protocol

Protocolsuite IPsec → Authentication header (AH-protocol) & encapsulation security payload (ESP-protocol)

AH-protocol → bronauthenticatie & gegevensintegriteit maar geen vertrouwelijkheid ESP-protocol → bronauthenticatie & gegevensintegriteit & vertrouwelijkheid Vertrouwelijkheid essentieel bij VPN & andere IP-sec applicaties

8.7.3 Beveiligingsassociaties

IPsec-datagrammen → verzonden tussen 2 netwerkentiteiten → voor bronentiteit IPsec-datagrammen verstuurt → 2 entiteiten → logische verbinding tot stand = beveiligingsassociatie → logische simplexverbinding → unidirectioneel van bron naar bestemmingsentiteit → beide entiteiten beveiligde datagrammen naar elkaar willen verzenden → noodzakelijk om 2 beveiligingsassociaties tot stand te brengen → voor elke richting 1

8.7.4 Het IPsec-datagram

2 verschillende packetvormen → tunnelmodus & transportmodus PAGINA 589 HANDBOEK

8.7.5 sleutelbeheer in IPsec (IKE)

IKE kent twee fase

Fase1:

opmerking: IKE SA anders dan IPsec SA ook bekend als ISAKMP security association

Fase 2:

fase 1 heeft twee modi: agressieve modus en hoofdmodus

IKE-berichtenuitwisseling voor algoritmen, geheime sleutels, SPI-nummers

 

8.8 Securing wireless LANs

8.8.1 Wired equivalent privacy

LEER VANUIT SLIDES $rarr; DUIDELIJKER

8.9 Operationele beveiliging: firewalls & intrusion-detectionsystemen

8.9.1 Firewalls

3 doelen:

Traditionele packetfilters

Filterbeslissingen meestal genomen op basis van:

Organisatie kan filteren op:

Filterpolicy kan gebaseerd zijn op combinatie van adressen & poortnummers

Stateful packetfilters

Bewaken alle bestaande TCP-verbindingen → firewall kan nieuwe verbinding detecteren → door 3-wayhandshake (SYN, SYNACK & ACK) → + eind verbinding detecteren → FIN-packet → firewall kan ook veronderstellen → verbinding niet meer nodig is → geen activiteit

Packet bereikt firewall

  1. Firewall controleert lijst met toegangsbeheer ( traditionele packetfilters )
  2. Verbindingstabel controleren voor packet in netwerk van organisatie kan komen
  3. Controleert verbindingstabel → geen deel van lopende TCP-verbinding → weigert
  4. IF webserver stuurt packet terug → firewall controleert tabel → overeenkomstige verbinding → packet passeren

Application gateway

Firewalls moeten packetfilters combineren met applicatiegateways → die kijken verder dan headers van IP, TCP & UDP → beslissingen op basis van applicatiegegevens Applicatiegateway → applicatiespecifieke server die door alle applicatiegegevens gepasseerd moet worden → verschillende applicatiegateways kunnen op dezelfde host uitgevoerd worden → elke gateway afzonderlijke server met eigen processen

Stel:

Firewall → geselecteerde groep interne gebruikers → Telnet-verbindingen met externe netwerken → tegelijk voorkomen → externe clients → Telnet-verbinding maken met interne host

Stel nu:

Interne gebruiker wil verbinding tot stand brengen met buitenwereld

  1. Gebruiker Telnet-sessie starten met applicatiegateway → op gateway draait applicatie → wacht voor inkomende Telnet-sessies tot stand komen
  2. Applicatie vraagt username & password
  3. IF informatie = correct → applicatiegateway checkt IF gebruiker = gerechtigd is → als dat het geval is
  4. Gateway vraagt gebruiker → hostname externe host ingeven
  5. Gateway Telnet-sessie → tussen gateway & externe host
  6. Gateway verzendt alle gegevens afkomstig van externe host naar gebruiker & omgekeerd

8.9.2 Intrusion-detectionsystems

IDS + IPS = IDS

Organisatie → meerdere IDS's sensoren implementeren → meestal samenwerkend → sturen verdachte verkeersactiviteit → centrale IDS-processor → verzamelt info → alarmen verzendt naar netwerkbeheerder wanneer nodig

Pagina 619 afbeelding 3.6

Organisatie → 2 delen opgesplitst

  1. Streng beveiligd deel → afgeschermd door → packetfilter & applicatiegateway → bewaakt door IDS sensoren
  2. Minder streng beveiligd deel →gedemilitariseerde zone (DMZ)→ alleen beveiligd door packetfilter maar ook bewaakt door sensoren IDS (is een netwerksegment dat zich tussen het interne en externe netwerk bevindt. Het externe netwerk is meestal het Internet. Een DMZ is feitelijk een andere naam voor een extranet, een gedeelte van het netwerk dat voor de buitenwereld volledig toegankelijk is. Op het netwerksegment van de DMZ zijn meestal servers aangesloten die diensten verlenen die vanuit het interne en externe netwerk aangevraagd kunnen worden)

Sensoren voor IDS → verderop in systeem → elke sensor deel van dataverkeer → gemakkelijker taak uitvoeren

IDS systemen in 2 categorieën

  1. Systemen die werken met handtekeningen

Beperkingen:

  1. dit soort IDS → alleen als voorkennis over aanval is → gebruikt nauwkeurige handtekening te vervaardigen → blind als er nieuwe aanvallen zijn

  2. packet → zelfs als er bekende handtekening is → niets te maken met een aanval → false-positive warning

  3. IDS kan overvoerd geraken → elk packet vergeleken moet worden → uitgebreide verzameling handtekeningen → kan zover komen dat IDS schadelijke packets niet detecteert

  4. Op anomalie gebaseerde systemen

Snort

Maakt gebruik van generieke sniffingsinfterface, libpcap

Enorme groep gebruikers & beveiliginsexperts → houden handtekeningdatabase actueel

9 Multimedianetwerken

9.1 Multimedianetwerkapplicaties

9.1.1 Eigenschappen van video

9.1.2 Eigenschappen van audio

9.1.3 Soorten multimedianetwerkapplicaties

Streamen van opgeslagen audio / video

Streamen van opgeslagen video 3 belangrijke onderscheidende kenmerken

VOIP

Timing is belangrijk → spraak- en videoapplicaties → vertragingsgevoelig → meeste multimedianetwerkapplicaties → bestand tegen een zekere mate van gegevensverlies → resulteert in korte onderbrekingen van audio of video

Streamen van live audio & video

Meestal via CDN's → zelfde snelheid weergeegven als orgineel → gegevens op tijd van server ontvangen → voor moment client moet weergeven → anders haperingen → omdat evenement = live → vertraging probleem zijn → timingeisen minder streng dan voor spraakgebrekken

9.2 Streamen van opgeslagen video

2 belangrijke voordelen bufferen door client

  1. Fluctuaties in vertraging tussen server en client opvangen
  2. Banbreedte tussen server & client → daalt onder sneheid → waarmee videocontent wordt weergegeven → blijven kijken zolang buffer van clientcomponent niet leegraakt

9.2.1 Streamen met UDP

Kleine buffer op clientcomponent van applicatie gebruikt → net groot genoeg voor minder dan seconde video → server die video aan UDP-verbinding vertrouwt → stukjes video verpakken in transportpackets speciaal ontworpen voor transporteren audio & video → Realtime Transport Protocol ( RTP )

Server & client → onderhouden verbinding voor videostream → ook afzonderlijke besturingsverbinding die door client wordt gebruikt geven opdrachten

Systeem 3 belangrijke nadelen:

  1. Streamen met constante snelheid → voor continue weergave → problemen opleveren als gevolg van onvoorspelbaare & wisselende beschikbare bandbreedte
  2. Streamen met UDP → server nodig om media te besturen → interactieve verzoeken tussen client en server afhandelen & toestand client bewaren → voor elke sessie
  3. Veel firewalls geconfigureerd om UDP verkeer te blokkeren

9.2.2 Streamen met HTTP

Video in HTTP server → gewoon bestand met specifieke URL → gebruiker wil video zien

  1. Client start TCP-verbinding met server
  2. Verzendt HTTP-GET-bericht
  3. Server verzendt video bestand in HTTP-antwoordbericht
  4. Clientcomponent applicatie verzamelt bytes in buffer
  5. Zodra # bytes in buffer &gt; bepaalde drempelwaarde
  6. Client begint met weergave + videoframes periodiek uit buffer opgehaald & gecomprimeerd

Packets → vertraagd als gevolg opnieuw verzenden packets

Gebruik van HTTP over TCP → firewalls en NAT's gemakkelijker gepasseerd kunnen worden → van het UDP-dataverkeer tegen houden → HTTP-dataverkeer door te laten → streamen HTTP geen mediabesturingsserver nodig (RTSP-server) → kosten lager → meeste videostreamapplicaties werken met HTTP over TCP als streamprotocol

Prefetchen van video

Client probeert video downloaden → snelheid hoger dan weergavesnelheid → voorraad krijgen van videoframes → toekomst worden weergegeven

Buffers van clientcomponent van de applicatie & TCP-buffers

Volledige client applicatie buffer → legt indirect limiet op rate → video verstuurd van server naar client wanneer streamen over HTTP

Analyse van clientcomponent van applicatie en TCP-buffers

If beschikbare rate &lt; video rate → continue weergave afgewisseld worden → periodes beeld stilstaat → wanneer beschikbare rate in netwerk &gt; video rate → na initiele buffering vertraging → continous playout tot einde video

Vroegtijdige beëindiging van weergave & verplaatsen van weergavetijdstip

HTTP-byterange-headerveld in HTTP-get-verzoekbericht → bevat informatie → bereik in bytes van gewenste video → client wil ontvangen → If gebruik springt naar ander tijdstip in video → client verzendt nieuw HTTP-verzoekbericht → in byterangeheaderveld van bericht → clientapplicatie specifieert vanaf welke byte in bestand → gegevens wil ontvangen → server nieuw HTTP-verzoek ontvangt → alle eerdere verzoeken weg & bytes verzenden

9.2.3 Dynamic Adaptive Streaming over HTTP (DASH)

Gebruikt meerdere versies → zelfde video → elk een bepaalde snelheid waarmee gestreamd wordt → gecomprimeerd → CDN's vaak gebruikt distribueren opgeslagen & live video

9.3 Voice-over-IP (VoIP)

9.3.1 Beperkingen van best-effortdienst van IP

IP → zo snel mogelijk van bron naar bestemming → geen beloften → vertraging of packet loss → belangrijke consequenties → ontwerp realtime spraakapplicaties → gevoelig voor packetvertraging, jitter & verlies

  1. Verzender genereert bytes met snelheid → 8000 bytes/seconde → iedere 20 ms verzamelt bytes in stuk → chunk
  2. Chunk + speciale header → verpakt in UDP-segment → elke 20 ms UDP-segment verzonden

Als packet ontvanger bereikt → constante end-to-endvertraging → packets 20 ms na elke spraakactie van andere partij arriveren → ideale situatie → ontvanger elke chunk direct bij aankomst weergeven → sommige packets kwijt + niet zelfde end-to-endvertraging

Ontvanger moet

  1. Bepalen wanneer chunk moet weergegeven worden
  2. Bepalen wat er moet gebeuren als chunk ontbreekt

Packetverlies

Verlies zou voorkomen → packets over TCP versturen → mechanismen opnieuw verzenden packets → niet geschikt voor VoIP → vergroten end-to-endvertraging

Packetloss tussen 1% en 20% is acceptabel → afhankelijk hoe spraakgegevens gecodeerd & verzonden zijn → manier hoe ontvanger verlies maskeert → Forward Error Correction (FEC) → hulpvol zijn packetverlies maskeren

End-to-endvertraging

Totaal van

Ontvanger bij VoIP-applicatie → packets negeren die vertraging groter dan bepaalde drempelwaarde

Packetjitter

Variatie in queuing delays → packet in netwerkrouters ondervindt = cruciaal → deze vertragingen variëren → dus ook verstreken tijd tussen moment → verzenden packet & ontvangen packet → fenomeen = jitter → compenseren aan de hand van volgnummers , tijdstempels & weergavevertraging

9.3.2 Jitter voor audio compenseren bij ontvanger

Gedaan door 2 mechanismes combineren

  1. Elke chunk vooral laten gaan door tijdstempel → verzender voegt aan elk nieuw gegenereerd packet → informatie over tijdstip → packet werd gegenereerd
  2. Weergave chunks → bij ontvanger vertragen → weergave ontvangen chunks → vertraagd worden → zodat grootste deel packets ontvangen is voor weergeven

1) Onveranderlijke weergavevertraging

Ontvanger kan weergavevertragingen variëren

Chunk tijdstempel bij afzender op tijdstip t → ontvanger speelt chunk (q) af op tijdstip t + q → assuming chunk tegen die tijd gearriveerd → packets na hun geplande speeltijd arriveren → weggegooid

2) Variabele weergavevertraging

Door initiële weergavevertraging groot te maken → meestg packets op tijd aankomen → verloren packets = klein →weergavevertraging variëren aan begin elke spraaksessie → stiltes voorafgaand aan spraaksessie → verkort of verlengd → niet hoorbaar wanneer verleningen / verkortingen stiltes niet te groot zijn

9.3.3 Compenseren van packetverlies

Forward Error Correction ( FEC )

Mechanisme 1:

Verzendt redundant gecodeerde 'chunk' na elke n chunks → geconstrueerd door exclusieve OR-bewerking uit te voeren op n oorspronkelijke chunk.

Als willekeurig packet van groep n+1 kwijtgeraakt → ontvanger verloren packet reconstrueren → meer dan 2 niet mogelijk → verhoogt overdrachtssnelheid & weergavevertraging

Mechanisme 2:

Versturen van lagere resolutie audio stream → verzender genereert n-de packet door n-de chunk van nominale stream achter (n-1) de chunk van redundante stream te plaatsen → wanneer meerdere niet opeenvolgende packets kwijtraken → ontvanger verlies compenseren door chunk met lage bitsnelheid → volgende packet "meelift" geven → lagere geluidskwaliteit

Interleaving

Verzender verstuurt eenheden audiogegevens in andere volgorde → oorspronkelijk aangrenzende eenheden in verzonden stream gescheiden zijn door afstand → effect packetverlies verkleinen → if packetloss → meeste van elke orginele chunk → geen redundantie overhead → verhoogt playout delay → voordeel → benodigde bandbreedte voor een stream niet vergroot

Maskeren van fouten

Herhalen van packets → ontvanger vervangt kwijtgeraakte packets door kopieën

Interpolatie → kwijtgeraakte packet berekend p basis van voorgaande & volgende packet in stream

9.3.4 Casus: VoIP met Skype

Meeste thuisnetwerken → NAT netwerken → NAT voorkomt host buiten thuisnetwerk verbinding met host binnen thuisnetwerk → beide Skype-bellers NAT → probleem

Super peers lossen probleem op

  1. Alice logt in → superpeer buiten netwerk toegewesen → Alice & superpeer besturingsberichten uitwisselen → idem voor Bob
  2. Alice belt Bob → informeert Alice superpeer → superpeer Bob informeert → brengt Bob op hoogte → inkomende oproep Alice
  3. Bob accepteert → 2 superpeers kiezen 3e superpeer zonder NAT → gegevens Alice en Bob uitwisselen aan elkaar koppelen

Conference calls → elke gebruiker verzendt audiostream naar deelnemer die gesprek start → deelnemer combineert audiostreams tot 1 enkele stroom → verzendt kopie van elk gecomineerde stream → elk van andere N-1 deelnemers → video elke deelnemer → gestuurd in servercluster

9.4 Protocollen voor realtime spraakapplicaties

9.4.1 RTP

Gebruikt PCM,MP3,... te transporteren

Basisprincipes van RTP

RTP boven op UDP

  1. Verzendende component verpakt chunk media-gegevens in RTP-packet
  2. Verpakt packet in UDP-segment → naar IP
  3. Ontvangende haalt RTP-packet uit UDP-segment
  4. Chunk → mediaplayer → decodeert & weergeven
  5. Verzendende omponent voegt voor elke chunk audiogegevens → RTP-header toe
  1. RTP packet → in UDP socket interface
  2. Ontvanger → applicatie ontvangt RTP van socket interface
  3. Applicatie filtert audiogegevens & headervelden van RTP packet → gegevens decoderen & afspelen

RTP geen mechanismen → tijdige bezorging van gegevens of kwaliteit diensten → geen garantie of packets aankomen of juiste volgorde

RTP → elke bron → eigen onafhankelijke RTP-packetstream → routers geen onderscheid tussen IP-datagrammen met RTP-packets & zonder RTP-packets

Headervelden van RTP-packet

9.4.2 SIP

Gesprek tot stand brengen met bekend IP-adres

  1. Alice stuurt Bob → SIP INVITE bericht → over UDP naar poort 5060 voor SIP → geeft poort aan
  2. INVITE-bericht identificatie voor Bob + indicatie huidig IP van Alice & preferred codering
  3. Bob antwoord met 200 OK bericht → poort weer, IP & preferred codering
  4. Na ontvangen Bob antwoord → SIP ontvangst bericht → erna praten

SIP kan over TCP of UDP verstuurd worden → default port 5060 → SIP berichten verstuurd en ontvangen in sockets → andere dan voor media data

SIP berichten → ASCII leesbaar → lijken op HTTP-ber

SIP-berichten

Kijk pagina 663. Voor voorbeeld

Vertalen van namen en het traceren van een gebruiker

Alice kent alleen e-mailadres Bob → dit adres ook voor SIP-gesprekken

Hoe kent proxyserver het huidige IP-adres van bob@domain.com

Elke SIP-gebruiker → registrar gekoppeld

  1. Gebruiker start SIP-applicatie
  2. Applicatie verzendt SIP-registerbericht naar registrar → informatie huidig IP gebruiker
  3. Registrar Bob → bijhouden huidig IP-adres Bob → ander SIP-apparaat → nieuw registerbericht met nieuw IP

Gebruik langere tijd → register blijft registerberichten sturen → registrar overeenkomsten met DNS-name-server → vertaalt vaste hostnamen naar vaste IP → SIP-registrar vaste menselijke identificatiegegevens → dynamische IP-adressen → SIP-registrars & proxy's op zelfde host

 

 

 

Hoe kan SIP proxy huidige IP-adres van Bob achterhalen

  1. Alice verstuurt INVITE-bericht → SIP-proxy Bob
  2. Proxy stuurt bericht naar SIP-apparaat van Bob
  3. Bob ontvangt Alice INVITE-bericht → kan antwoord sturen naar Alice

Jim@umass.edu (217.123.56.89) wil VoIP starten met Keith@upenn.edu (197.87.54.21)

  1. Jim verzendt INVITE-bericht naar SIP-proxy van umass
  2. Proxy → DNS-lookup voor SIP-registrar upenn.edu → verzendt bericht naar registrarserver
  3. Keith.upenn.edu → niet bekend bij registrar upenn → registrar omleidingsantwoordbericht → melding → umass keith.nyu.edu moet proberen
  4. Proxy umass → INVITE-bericht → SIP-registrar van NYU
  5. Registrar NYU → kent IP van keith@upenn.edu→ stuurt INVITE-bericht door naar host 197.87.54.21 → SIP-client van Keith uitvoert.
  6. Verzendt SIP-antwoordbericht → registrars/proxy's → terug naar SIP-client → 217.123.56.89
  7. Idem 6
  8. Idem 6
  9. Media → rechtstreeks tussen 2 clients verzonden → ook ACK

9.5 Netwerkondersteuning voor multimedia

9.5.1 Best-effortnetwerken dimensioneren

Eerste manier kwaliteit multimedia-applicaties te verbeteren →

Meer geld uitgeven

Bij multimedia in netwerken → voorkomen tekort aan recources → als linkcapaciteit → groot genoeg → packets door huidige internet getransporteerd → zonder queuing delays of kans op vermissing

Vraag is → hoeveel capaciteit nodig? → kosten leveren benodigde bandbreedte → reële zakelijke optie is voor ISP's → hoe groot capaciteit netwerklinks → bepaalde topologie → bepaalde end-to-endperformance te leveren = netwerkdimensioneringsprobleem

Volgende problemen moeten opgelost worden om performance van applicatielaag tussen 2 eindpunten in netwerk te kunnen voorspellen

  1. Modellen van het benodigde dataverkeer tussen eindpunten in het netwerk
  1. Goed gedefinieerde performance-eisen
  1. Modellen om end-to-endperformance bij een bepaald netwerkbelastingsmodel te voorspellen en technieken om zo gering mogelijke kosten zodanig bandbreete toe te wijzen dat aan alle eisen van de grebruikers wordt voldaan

9.5.2 Verschillende soorten diensten verlenen

Eenvoudigste uitbreiding → dataverkeer voor unitaire & egalitaire best-effortdienst → huidige internet opsplitsen in categorieën → bij dienstverlening aan verschillende categorieën → verschillende niveaus

Een paar scenarios

Principe 1: Packet markering → markeren van packets → router packets die horen bij verschillende dataverkeercategorieën van elkaar onderscheiden → originele doel (ToS) veld in IPv4

Principe 2: Isolatie dataverkeer → zekere mate van isolatie tussen categorieën implementeren → ene klasse niet nadelig beïnvloed kan worden → als iets mis is met andere categorie

2 aanpakken mogelijk:

  1. Dataverkeerpolicy → als dataverkeercategorie moet voldoen aan bepaalde criteria → controlemechanisme → zorgen policy nageleefd → als applicatie niet aan criteria houdt → mechanisme handelend optreden → dataverkeer netwerk binnenkomt voldoet aan criteria
  2. Packetschedulingmechanisme op datalinklaag → expliciet een constante hoeveelheid van linkbandbreedte te laten reserveren → elke categorie

Principe 3: Belangrijk categorieën van elkaar scheiden → wenselijk recources → efficiënt mogelijk te benutten → manier packets in wachtrij voor verzending over link worden geselecteerd = link-schedulingmethode

Leaky bucket

Policing = belangrijk QoS-mechanisme

3 policycriteria:

  1. Gemiddelde snelheid: Netwerk kan gemiddelde snelheid van packets van stream langere tijd beperken → cruciale factor → tijdsduur waarover de gemiddelde snelheid zal worden geregeld → bron begrensd 100 packets per seconde → sneller afgeremd dan bron 6000 packets/min → zelfs beide bronnen → zelfde gemiddelde snelheid
  2. Maximale snelheid: beperking van gemiddelde snelheid → begrenst hoeveelheid dataverkeer → in netwerk gezonden kan worden → relatief lange periode → beperking van maximale snelheid → begrenst # packets verzonden in korte periode
  3. Burstgrootte → Netwerk kan ook max # packets → begrenzen → dat gedurende extreem korte periode via netwerk wordt verzonden

Buckets bestaan uit → bucket dat max b tokens bevat

  1. Nieuwe tokens → in bucket → snelheid van r tokens per seconde genereerd
  2. IF bucket &lt; b tokens → token direct in bucket
  3. Else → token genegeerd → bucket blijft gevuld met b tokens

Stel packet voor het verzonden wordt → token uit bucket halen

Omdat maximaal b tokens in bucket zitten → maximale burstgrootte voor een met leaky bucket begrense stream gelijk aan b packets

Tokens genereerd met snelheid r → maximale aantal packets → netwerk kan binnenkomen in willekeurige periode met lengte t → rt + b → snelheid r waarmee tokens genereerd worden → maat om gemiddelde snelheid → packets netwerk kunnen binnenkomen op lange termijn → begrenzen

9.5.3 Diffserv

Diffserv → differentiatie in dienstverlening → mogelijkheid verschillende categorieën dataverkeer → internet schaalbare manier

2 functionele elementen

  1. Functies aan de edge: → classificeren en coditioneren van dataverkeer → ingaande edge netwerk ( bij Diffserv-host die dataverkeer genereert of eerste Diffserv-router waarlangs dataverkeer passeert) → arriverende packets gemarkeerd
  2. Functies in de core → doorverzenden → wanneer Diffserv gemarkeerd packet → arriveert Diffserv router → doorverzonden naar volgende hop → volgens 'per-hop' voorschrift → geldt voor betreffende categorie packets → 'per-hop' voorschrift uitsluitend gebaseerd op markering van packet ( Diffserv-model)

Packets die bij edgerouter aankomen → gaclassificeerd & gemarkeerd (AFBEELDING p.679)

  1. Classificeerder selecteert packets → basis 1 of meer waarden in headervelden
  2. Verzendt packet naar betreffende markeerfunctie

Sommige gevallen host afgesproken → packetverzendsnelheid → sturen → voldoet aan bepaald dataverkeerprofiel → kan limiet op maximale overdrachtsnelheid bevatten of maximale # packets verzonden in korte tijd

Zolang gebruiker packets verzendt → voldoen aan overeengekomen waarden in dataverkeerprofiel → packets voorkeursbehandeling → wanneer verzender niet houdt aan dataverkeerprofiel, packets buiten overeenkomst vallen → andere markering of vertraagd worden of zelfs genegeerd worden aan edge netwerk

Meetfunctie → ingaande stream vergelijken met overeengekomen dataverkeerprofiel → bepalen packet binnen dat profiel past → eigenlijke beslissing over packets → netwerkbeheerder

In per-hop gedrag belangrijke overwegingen

2 'per-hop' voorschriften gedefinieerd

  1. Expedited forwarding → 'per-hop' voorschrift → vertreksnelheid van categorie → bij router = &gt; dan geconfigureerde snelheid
  2. Assured forwarding → 'per-hop' voorschrift → verkeer in 4 categorieën → elke AF-categorie gegarandeerd → bepaalde minimale hoeveelheid bandbreedte & buffers

End-to-end-Diffserv-dienst leverren → alle ISP's tussene eind systemen → service leveren & samenwerken & afspraken maken → klant → gedifferentieerde end-to-end dienst te bieden

 

9.5.4 Per verbinding Qos-garanties geven: recources reserveren & streams toelaten

Principe 4: Nood aan nieuwe netwerk mechanics en protocollen → duidelijk wanneer stream gegearandeerde service moet ontvangen zodra gestart is

  1. Recources reserveren → enige manier garanderen → stream beschikken over benodigde recources → recources gereserveerd → stream naar behoefte benutten → gedurende gereserveerde tijd ongeacht behoeften andere streams
  2. Streams toelaten → recources gereserveerd → netwerk mechanisme hebben → streams verzoeken kunnen richten → recources niet oneindig → verzoek stream afgewezen → als gevraagde recources niet beschikbaar zijn
  3. Signaleren set-up streams → toelatingsproces → stream die QoS nodig heeft → voldoende recources reserveren → elke netwerkrouter tussen bron & bestemming → zeker zijn end-to-end-QoS-eisen hebben → elke router → lokale recources voor nieuwe stream nodig zijn berekenen → bekijken hoeveel beschikbare recources in gebruik zijn → opgestarte streams → of bepalen beschikbare per hop → toereikend QoS-eisen → honoreren Signaliseringsprotocol nodig activiteiten coördineren = call-setupprotocol → RSVP-protocol → voorgesteld voor dit doel binnen internetarchitectuur (PAGINA 683 AFBEELDING)

Active vs Passive FTP

Active FTP

  1. Client contacteert server op command poort
  2. Server stuurt ACK terug naar client's commandpoort
  3. Server initieert connectie op lokale datapoort → naar datapoort client eerder aanduidde
  4. Client stuurt ACK terug

 

Passive FTP

  1. Client contacteert server op command poort
  2. Server antwoord met poort 2024 → server verteld welke poort luisterd voor data connectie
  3. Client initieert data connectie van zijn datapoort → gespecifieerde data poort
  4. Server stuurt ACK terug naar client's datapoort

Active → SYN door client Passive → SYN door client

2020 juni examen

(Corona) - P. Geens

Theorie

+- 24 multiple chose vragen

Praktijk

Bij elke vraag moest je deze vorm van input meegeven: "oneliner - outputhash md5sum" ('| mdsum' toevoegen aan je oneliner geeft je de hash terug van je output)

ls -ld /etc
tshark -r /home/logs/Cnw2_ftp.pcap -Y 'ftp.request.command==USER' -T fields -e 'ftp.request.arg' | sort | head -1
echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -noout -text
cat /home/logs/secret | openssl enc -a -d

2020 juni examen - versie 2

Examen Juni 2020

Dit examen was tijdens de corona periode. Labo en theorie waren dus samen gevoegd.

Voor theorie: zie het bestande THEORIE.md

Dank aan: Pablopicasso en ISW

cn2_examen_juni2020.zip is gewoon een kopie van de Toledo website op dat moment,

Labo

Instructies

Het examen is gesloten boek, je mag enkel gebruik maken van onderstaande hulpmiddelen:

Antwoorden bestaan steeds uit een enkele ‘oneliner’, net zoals in de geziene labo’s en het voorbeeldexamen. Je mag commando’s aan elkaar lijmen met unnamed pipes ( | symbool), maar &&, || en ; mogen enkel gebruikt worden wanneer dit echt noodzakelijk is (bijvoorbeeld voor de syntax van een for-loop).

Let op: Bij sommige opdrachten staat er vermeld welke commando's je (niet) mag gebruiken.

Veel succes!

Vraag 1 (voorbeeld): 0 punten

Dit is een voorbeeld vraag, inclusief het correcte antwoord. Bekijk ze goed, zodat je weet wat er exact verwacht wordt.

Maak een CLI oneliner die de directory permissies, eigenaar, groep,... (via ls -l) oplijst van de /etc directory zelf (niet van de inhoud) op server leia.

Daarna pipe je de output van je CLI oneliner in het commando md5sum. In het antwoordveld vul je beide in op deze manier:

ONELINER - md5 hash
Oplossing:
# Met deze onliner kan je de permissies,... opvragen van de /etc directory zelf:
ls -ld /etc
# En zo pipe je de output van deze oneliner in md5sum:
ls -ld /etc | md5sum

# En dit vul je in in het antwoordveld:
ls  -ld /etc - 69ede2180c67f4a59fea0206e031101f

Vraag 2: 10 punten

Het bestand Cnw2_ftp.pcap bevat een opgenomen FTP sessie. Je kan dit bestand vinden in /home/logs op server leia.

Maak een CLI oneliner met tshark die de gebruikersnaam toont van de gebruiker die succesvol inlogde. Enkel de gebruikersnaam mag getoond worden. Dus geen witregels, geen errors, geen andere tekst.
In je oneliner mag je enkel gebruik maken van het commando tshark. Geen enkel ander commando is toegestaan. Je mag wel gebruik maken van Wireshark als hulpmiddel om de juiste display filter ('s) te vinden.

Oplossing
tshark -r /home/logs/Cnw2_ftp.pcap -Y "ftp.request.command==USER && tcp.srcport==$(tshark -r /home/logs/Cnw2_ftp.pcap -Y "ftp.response.code==230" -T fields -e tcp.dstport)" -T fields -e ftp.request.arg

# Deze kan ook maar is waarschijnlijk niet altijd juist
tshark -r /home/logs/Cnw2_ftp.pcap -Y 'ftp.request.command==USER' -T fields -e 'ftp.request.arg' | sort | head -1

Vraag 3: 10 punten

Maak een CLI oneliner met openssl die het certificaat van de server wiki.uclllabs.be als tekst laat zien. Enkel dit mag getoond worden. Sample output:

Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number:
            0d:81:12:b8:1c:24:0c:f3:0d:46:af:cd:9a:9b:96:d2
        Signature Algorithm: sha256WithRSAEncryption
        Issuer: C = NL, ST = Noord-Holland, L = Amsterdam, O = TERENA, CN = TERENA SSL CA 3
        Validity
            Not Before: Jan 22 00:00:00 2020 GMT
            Not After : Jan 26 12:00:00 2022 GMT
        Subject: C = BE, L = Leuven, O = UC Leuven, CN = *.uclllabs.be
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (384 bit)
                pub:
                    04:f5:46:f9:2c:94:f0:86:bd:6f:59:32:7c:4d:82:
                    06:da:d7:87:38:cb:74:98:6d:66:c0:4c:ca:f4:9e:
                    1f:5a:22:25:43:11:07:d4:86:1d:68:92:82:d3:eb:
                    4a:a5:bd:fb:4a:46:84:86:ed:40:be:92:7d:f1:f2:
                    56:3b:2b:9f:eb:84:33:59:0d:62:ef:8d:68:ac:4d:
                    d2:76:84:8c:69:93:47:cc:09:a2:2d:19:9d:ba:c6:
                    e7:e8:03:01:7d:df:44
                ASN1 OID: secp384r1
                NIST CURVE: P-384
        X509v3 extensions:
            X509v3 Authority Key Identifier: 
                keyid:67:FD:88:20:14:27:98:C7:09:D2:25:19:BB:E9:51:11:63:75:50:62

            X509v3 Subject Key Identifier: 
                1B:19:0F:9E:AE:E4:39:61:82:08:79:0C:06:42:75:4A:EE:86:BF:6C
            X509v3 Subject Alternative Name: 
                DNS:*.uclllabs.be, DNS:uclllabs.be
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Extended Key Usage: 
                TLS Web Server Authentication, TLS Web Client Authentication
            X509v3 CRL Distribution Points: 

                Full Name:
                  URI:http://crl3.digicert.com/TERENASSLCA3.crl

                Full Name:
                  URI:http://crl4.digicert.com/TERENASSLCA3.crl

            X509v3 Certificate Policies: 
                Policy: 2.16.840.1.114412.1.1
                  CPS: https://www.digicert.com/CPS
                Policy: 2.23.140.1.2.2

            Authority Information Access: 
                OCSP - URI:http://ocsp.digicert.com
                CA Issuers - URI:http://cacerts.digicert.com/TERENASSLCA3.crt

            X509v3 Basic Constraints: critical
                CA:FALSE
            CT Precertificate SCTs: 
                Signed Certificate Timestamp:
                    Version   : v1 (0x0)
                    Log ID    : A4:B9:09:90:B4:18:58:14:87:BB:13:A2:CC:67:70:0A:
                                3C:35:98:04:F9:1B:DF:B8:E3:77:CD:0E:C8:0D:DC:10
                    Timestamp : Jan 22 11:03:02.541 2020 GMT
                    Extensions: none
                    Signature : ecdsa-with-SHA256
                                30:44:02:20:5B:C2:BD:AA:16:4F:D8:18:42:10:D7:48:
                                9D:37:37:0B:4D:D6:65:65:F1:BF:08:A4:8D:B4:81:31:
                                02:BF:15:06:02:20:0D:DB:02:07:86:E1:2B:C0:24:04:
                                BE:42:FC:13:5E:77:D5:BF:E9:4B:53:0D:F1:6D:5E:78:
                                51:0A:3F:E4:26:31
                Signed Certificate Timestamp:
                    Version   : v1 (0x0)
                    Log ID    : 87:75:BF:E7:59:7C:F8:8C:43:99:5F:BD:F3:6E:FF:56:
                                8D:47:56:36:FF:4A:B5:60:C1:B4:EA:FF:5E:A0:83:0F
                    Timestamp : Jan 22 11:03:02.760 2020 GMT
                    Extensions: none
                    Signature : ecdsa-with-SHA256
                                30:46:02:21:00:FF:25:60:84:19:69:76:91:D6:8E:C5:
                                54:ED:7C:D4:40:9F:9B:14:99:2F:22:89:F0:0A:3F:9E:
                                3F:15:98:A3:66:02:21:00:92:05:A1:8D:F3:06:A8:DD:
                                92:E2:86:83:54:C1:BC:F9:5F:03:2E:62:F9:DA:5A:17:
                                2D:F8:D1:E6:5B:A2:78:6A
                Signed Certificate Timestamp:
                    Version   : v1 (0x0)
                    Log ID    : EE:4B:BD:B7:75:CE:60:BA:E1:42:69:1F:AB:E1:9E:66:
                                A3:0F:7E:5F:B0:72:D8:83:00:C4:7B:89:7A:A8:FD:CB
                    Timestamp : Jan 22 11:03:02.616 2020 GMT
                    Extensions: none
                    Signature : ecdsa-with-SHA256
                                30:44:02:20:7E:42:D6:3A:55:8B:7B:5A:1E:E0:05:48:
                                09:80:89:E5:A5:7A:FD:8C:5F:EE:AB:2E:7E:D1:07:A0:
                                C2:B4:63:EA:02:20:3A:12:1E:14:28:50:F7:8D:C3:73:
                                EA:9E:6C:AB:5D:B4:A8:AE:27:4C:D1:40:18:23:80:1E:
                                F3:87:B8:A8:98:71
    Signature Algorithm: sha256WithRSAEncryption
         7b:8b:b1:71:c4:73:c9:1f:30:d9:74:ea:b0:e9:a3:a7:a0:7b:
         23:a3:24:cf:e4:c4:f3:8f:82:47:15:4a:e7:4a:05:da:57:0a:
         89:db:90:50:62:0f:a8:95:47:5a:22:eb:5b:2f:a3:fd:31:d0:
         b5:b1:86:02:a1:91:87:65:42:70:ea:fc:49:79:ea:2c:13:fb:
         b0:4e:a5:15:ab:80:82:9d:c9:82:e9:da:9e:bb:81:8a:f0:65:
         eb:ef:73:1c:e4:e2:69:ce:06:fc:38:92:fc:7a:06:72:ae:c7:
         7e:37:37:21:b9:71:52:93:ed:18:b4:5d:91:9c:95:48:62:d6:
         ed:ab:3a:db:1d:22:ed:01:de:7d:56:58:f3:0a:7a:49:4c:cb:
         8b:73:b9:5f:83:f8:c4:b3:1a:ec:54:52:b9:83:ae:db:f7:0b:
         b2:cb:76:d0:99:19:e9:26:f9:c2:12:5d:ec:ea:0b:e3:f4:28:
         8a:da:c2:f5:b3:76:a4:03:c7:02:da:d0:44:a8:7a:6b:19:a0:
         99:99:f4:e8:e9:6b:ab:2e:ce:c8:5f:31:bb:e9:bb:52:35:61:
         ed:5a:22:fa:1c:ed:d0:4c:fe:83:8d:78:8a:43:79:fa:a3:38:
         5b:c2:f0:6e:b5:13:8e:28:fc:c7:f4:2c:a1:fe:79:b4:5a:68:
         fa:41:d5:a3
Oplossing
echo | openssl s_client -connect wiki.uclllabs.be:443 2>/dev/null | openssl x509 -noout -text

Vraag 4: 10 punten

Met welke CLI oneliner kan je volgende string decoderen?

RGUgcHVudGVuIG9wIGRlemUgdnJhYWcgemlqbiBhbCBiaW5uZW4uCg==

Je kan deze string ook terugvinden in het bestand /home/logs/secret op server leia. Je mag enkel gebruik maken van het commando openssl. Geen andere commando's zijn toegestaan.

Oplossing
openssl base64 -d -in /home/logs/secret
# Of een andere oplossing:
cat /home/logs/secret | openssl base64 -d
# Of een andere oplossing:
echo "RGUgcHVudGVuIG9wIGRlemUgdnJhYWcgemlqbiBhbCBiaW5uZW4uCg==" | openssl base64 -d

Dit is ook mogelijk maar is volgende de vraag fout, je moet openssl gebruiken.

cat /home/logs/secret | base64 -d
# Of
base64 -d /home/logs/secret

Examenbestanden: 

2021 juni examen

Met dank aan ISW

Praktijk test 21-05-2021

Let op, er waren twee testen en dus ook meerdere vragen.

###             Vraag 2      

1. Maak een CLI oneliner waarmee je alle woorden die uit exact 14 unieke letters bestaan toont. Sorteer het lijstje in omgekeerd alfabetische volgorde. Gebruik hiervoor het bestand /usr/share/dict/dutch.

   Daarna pipe je de output van je CLI oneliner in het commando md5sum. In het antwoordveld vul je beide in op deze manier:
   oneliner - md5 hash

2 punten  

###             Vraag 3      

1. Maak een CLI oneliner die uit de capture http.pcapng (/home/logs op leia)  alle HTTP server strings laat zien en telt die niet de string Apache  bevatten als antwoord op je GET requests. Sorteer van groot naar klein.
   Sample output:

2 ClientMapServer
1 YouTube Frontend Proxy
1 sffe
1 Kestrel
1 ECS (ams/D1E7)
1 ECS (ams/499C)
1 downloads
1 CloudFront


Daarna pipe je de output van je CLI oneliner in het commando md5sum. In het antwoordveld vul je beide in op deze manier:
oneliner - md5 hash

2 punten  

###             Vraag 4      

1. Maak een CLI oneliner die alle unieke gebruikersnamen toont waarmee geprobeerd werd om in te loggen op de website http://darthvader.uclllabs.be/nw2/private. Maak gebruik van de capture http_basic_auth.pcapng (/home/logs op leia).

   Daarna pipe je de output van je CLI oneliner in het commando md5sum. In het antwoordveld vul je beide in op deze manier:
   oneliner - md5 hash

2 punten  

###             Vraag 5      

1. Maak een CLI oneliner waarmee je de uitgever, vervaldatum en  modulus (in deze volgorde) laat zien van het certificaat van de website  https://x.toledo.ucll.be.

   Daarna pipe je de output van je CLI oneliner in het commando md5sum. In het antwoordveld vul je beide in op deze manier:
   oneliner - md5 hash

2 punten  

###             Vraag 6      

1. Maak een CLI oneliner die de juiste (dus van vandaag) dag en datum toont zoals in onderstaand voorbeeld:

   Het is vandaag vrijdag (1996.09.13)

   Daarna pipe je de output van je CLI oneliner in het commando md5sum. In het antwoordveld vul je beide in op deze manier:
   oneliner - md5 hash

 

Theorie test 31-05-2021

theorie.pdf

 

Algemeen

Dit vak bestaat uit theorielessen en computerzittingen. In de computerzittingen worden er oefeningen gemaakt in Linux, via SSH op een server van school. De leerstof van de praktijk lijkt eerst zot moeilijk, maar zorg gewoon dat je genoeg oefent en durf vragen te stellen en uiteindelijk zal het zichzelf uitwijzen

Het examen bestaat uit twee delen: een theorie-examen op 10 punten in de normale examenperiode en een praktijkexamen in de laatste week van het semester dat eveneens op 10 punten staat. Alles wat bij de Wiki op de pagina theorie staat is te kennen theorie. Er komt sowieso een vraag gebaseerd op hetgeen er in de filmpjes of extra teksten staat. Bij de meerkeuzevragen van het theorie-examen is er is geen giscorrectie, maar alles moet juist zijn om punten te kunnen krijgen. Het aantal juiste antwoorden wordt gegeven. Het is goed mogelijk dat er vragen terugkomen.

Het onderwerp cryptografie is een moeilijk onderdeel van computernetwerken. Als je het niet erg vindt om eens wat te lezen: het boek Computer Networks: A top-down approach is een zeer goed boek.

De puntenverdeling was oorspronkelijk 14 voor het theorie-examen en 6 voor het praktijkexamen. In 2015-2016 werd dit een eerste jaars vak en in schooljaar 2016-2017 veranderde de puntenverdeling naar 10/10 waarbij 10 punten op de theorie en 10 op de labo's.