Uitgelicht

Gastcollege

Security is belangrijk, en een gigantisch groot onderwerp in de media. Hierdoor zijn er ook een heel aantal misverstanden zijn over security op het web en op online apps. Deze misverstanden bestaan niet alleen bij de gewone mens, maar ook zeker bij de bedrijven.

Zo heb je bijvoorbeeld het misverstand: onze applicatie is veilig op ons netwerk, want wij hebben een firewall.

Dit is helaas niet echt een goede redenering, omwille van de samenwerking van de firewall en de router die het bedrijf van internet voorziet. Deze laatste heeft verschillende poorten, een soort van deuren waarlangs je toegang hebt, en de firewall blokkeert de meeste van deze poorten. Alleen is het probleem dat de weg waarlangs je op de applicatie op internet gaat, dezelfde is die niet kan geblokkeert worden door de firewall, omdat je anders niet door kunt, en ook nog eens dezelfde poort is waarlangs hackers binnen komen.

De hacker, ook wel de attacker genoemd, heeft altijd een model. Een hacker kan bijvoorbeeld inbreken in de verbinding tussen jou en de server waarmee je verbindt. Hij kan ook een andere techniek gebruiken, zoals een reflectie-techniek. Dit betekent zoveel als inloggen op de server, en wachten tot jij er bent om via jouw verbinding in jouw computer te geraken.

Als gevolg van deze verschillende modellen die een hacker kan hebben, kun je dus besluiten dat je niemand met jouw web applicatie kunt vertrouwen, en dus het stuk dat waar je controle over hebt, zoveel mogelijk moet beveiligen.

Er bestaan meerdere statistieken over wie er achter de vele aanvallen zit. Uit deze statistieken kunnen we besluiten dat de meeste aanvallen van buitenaf komen, maar dat een kleiner percentage ook van internen komt, dus van binnen het bedrijf.

Er zijn 2 grote soorten van attacks: de technische attacks, en de business logic attacks. Voor de eerste soort bestaat er een top 10 van de meest kritieke security risico’s voor web apps, namelijk de OWASP Top 10. Ondanks deze top tien de meest kritieke risico’s bevat, bestaan er in de realiteit nog veel meer, en is een top 10 tegelijk ook een top(je) van de ijsberg. Hieronder staat de OWASP top 10 van 2017:

  • Injection
  • Broken aunthetication
  • Sensitive data exposure
  • XML external entities
  • Broken Access Control
  • Security Misconfiguration
  • Cross-Site scripting
  • Insecure Deserialization
  • Using components with known vulnerabilities
  • Insufficient logging and monitoring

De meeste van deze risico’s worden niet veroorzaakt door de developer, maar wel door het design.

Voor de tweede soort worden vooral veroorzaakt door de developer. Hier is het probleem dat de business logic de code vermoeilijkt en soms zelfs onveilig en onjuist maakt.

Om software te developpen op een consequente en efficiente manier met een demonstreerbare en gestandaardiseerde security qualiteit, gebruiken developpers de SDLC (Secure Development LifeCycle). Dit houdt evenveel in als zeggen dat het meeste werk van beveiliging in de analyse en het design wordt gedaan, en in mindere mate in de technische fases. Dit dient om de meeste fouten en de gebreken uit de applicatie te halen nog voor dat er een letter code geschreven is.

W6: CI/CD GiP

De huidige situatie van de CI/CD cyclus van ons GiP is op basis van CI voorlopig nog niets, en binnen het GiP werken we niet met CD (Continuous Delivery) maar met DevOps. Aangezien er een aantal beperkingen zijn van wat we in/met ons GiP mogen doen, kunnen we alleen hieraan Unit tests toevoegen. Dit is dan binnen het concept van CI (Continuous Integration).

W7: Autorisatiemodel Leerplatform

U leest het goed, een autorisatiemodel voor het Leerplatform (Ook wel GiP-opdrachten genoemd) (En ja de spelling klopt, ik heb het opgezocht op google). Aangezien het Leerplatform een platform is voor docenten en studenten om zich op in te schrijven en op die manier lessen te maken en te volgen, moet natuurlijk niet zomaar iedereen op dat platform kunnen zitten. Want wat als eenderwie ineens een eigen planning kan aanmaken? Of nog sterker, wat als elke student ineens elk vak zou kunnen aanpassen of zelfs verwijderen, en eigen vakken zou kunnen aanmaken? Dat mag natuurlijk niet gebeuren, en daarom maak ik een autorisatiemodel in het Leerplatform. Het autorisatiemodel dat ik gebruik, is Identity van Asp.net Core. Het is een Role-based model dat niet voor gigantisch sterke veiligheid zorgt, maar goed genoeg is om voor onze applicatie te gebruiken. Ik hoor nu al dat het bij jullie in Keulen dondert. “Wat is Role-based?” zal waarschijnlijk de meest voorkomende vraag zijn. Daarom een korte uitleg. Role-based wil zeggen dat je gaat bepalen dat bepaalde acties alleen mogelijk zijn voor gebruikers met een bepaalde rol. Bijvoorbeeld kun je zo zeggen dat de actie van het aanmaken van een vak alleen beschikbaar is voor gebruikers met een docentenrol. Ben je een gebruiker met alleen een studentenrol? Jammer maar helaas, maar je zult vrede moeten nemen met wat er staat. Op die basis werk ik ook in het Leerproject. De acties die moeten beschermd worden van de buitenwereld, zet ik 1 of meer mogelijke rollen op, zodat ook binnen de applicatie niemand iets onrechtmatig kan doen. Alle acties waar data aan gekoppeld is (de home-pagina dus niet) zijn allemaal van autorisatie voorzien. Binnen de pagina-groepen (in vakstermen controllers genoemd), die gecentraliseerd zijn rond 1 soort van data, bijvoorbeeld vak of lokaal (planning en les zijn hier een uitzondering op) zijn er ook indien nodig andere of extra mogelijke rollen aan toegekend. Zo mag een student wel de vakken raadplegen om zich te kunnen inschrijven of uitschrijven voor dat vak, maar hij kan niet (nee zelfs niet via de URL) deze gegevens wijzigen, verwijderen of nieuwe gegevens maken. Een docent daarentegen moet ook de vakken kunnen raadplegen, maar heeft dan weer niet de nood (en dus ook niet het recht) om zich in- of uit te schrijven voor een vak. Een docent kan dan weer wel die inschrijvingsaanvragen goed- of afkeuren, en alle gegevens bewerken en nieuwe aanmaken. Ik heb voor deze aanpak gekozen, omdat eenerzijds dit zo was aangeboden, maar anderzijds ook zeer simpel, en toch handig en sterk in gebruik is. Je kunt niet zeggen met alleen de rollen dat iedere student zijn eigen gegevens over de vakken ziet, maar daar zijn andere oplossingen voor, ook binnen Identity.

W6: DRP voor GiP

Hier zal ik een kort DRP (Disaster Recovery Plan) voor mijn GiP-project Leerplatform opstellen. Voor meer info over het GiP-project raad ik aan om mijn blogpost W6: BCP voor GiP te lezen. Deze blogpost kun je een beetje zien als het vervolg op die van het BCP.

Een DRP is een plan om te garanderen dat de data en/of de applicatie zal blijven beschikbaar zijn ongeacht de ramp die op dat moment gebeurd is of aan het gebeuren is.

In het Leerplatform zal dit als volgt gaan:

Punt 1: Applicatie en database op dezelfde server

Een ding waar we rekening mee moeten houden, is dat de applicatie en de database op dezelfde server staan. Hierdoor kan het zijn dat beide tegelijk wegvallen door een beschadiging aan de hardwarematige server. Hiervoor bestaat een oplossing: zoals ook al in de vorige blogpost (W6: BCP voor GiP) was gezegd in punt 2, wordt er sowieso een extra gebouw met een server in gezet op een andere plaats, om dergelijke ongelukken te voorkomen. Als dus een natuurramp zou gebeuren kunnen we nog altijd overschakelen naar de tweede server als back-up. Aangezien dit gebouw overal ter wereld kan gezet worden (ook ondergronds) kunnen we zo voor tussen de 95 en de 99 procent garanderen dat in elk geval van een oorlog of natuurramp, de applicatie en de data continue beschikbaar zullen blijven. Ook als de originele server niet meer werkt door dergelijke rampen, zal er een mail gestuurd worden naar elke gekende gebruiker dat de server plat ligt, of kapot is, en er zo snel mogelijk zal worden overgeschakeld naar de reserveserver. Hier komt ook de melding bij te staan dat we kunnen garanderen dat de data en de applicatie zal beschikbaar blijven, zolang ook deze server niet afgebroken wordt.

W6: BCP voor GiP

Hier zal ik een beperkt BCP (Business Continuity Plan) opstellen voor mijn eigen GiP-project genaamd Leerplatform maken. Even ter info: het Leerplatform is een soort van simpele versie van Toledo bij de hogescholen in combinatie met een soort van roosterplanning van de lessen.

Punt 1: Impact

Aangezien dat het Leerplatform een webapplicatie is om de lessenroosters van 1 of mogelijks zelfs een groep van hogescholen te maken en te kunnen consulteren, is de impact vrij groot als deze applicatie weg zou vallen. Ten eerste zou geen enkele student nog weten waar hij wanneer welke les heeft. Daarenboven kan geen enkele student zich nog inschrijven voor een vak, laat staan dat een docent een student kan toewijzen aan een planning/lessenrooster. En het idee van een lessenrooster bij te maken of aan te passen? Laat dat maar helemaal zitten, want applicatie weg = alle functionaliteiten weg. De eneige manier waarop de studenten hun lessenrooster zouden kunnen te weten komen, is als de roosterplanners of de docenten naar elke student hun lessenrooster voor die student en die richting door zou sturen via mail.

Punt 2: Mogelijke preventieve maatregelen

Er zijn heel wat gevaren die op de loer liggen om onze applicatie kapot te maken. De bekendste voorbeelden zijn natuurlijk hackers, saboteurs en ook het verkeerdelijk gebruik van de applicatie door de gebruikers. Andere voorbeelden die vaak vergeten worden zijn bijvoordbeeld een pandemie (heel actueel nu met COVID-19 aka het corona-virus), natuurrampen (aardbevingen, tsunami’s (of andere overstromingen), brand, …) en natuurlijk ook door de mens gemaakte destructies (oorlog, terrorisme, …). Het is moeilijk maar er zijn wel een aantal mogelijke maatregelen om te nemen tegen deze gevaren. Ten eerste moeten de developers er in de code en de IT’ers van het netwerk er zo veel mogelijk voor zorgen dat hackers niet kunnen inbreken in de applicatie. Dit kan met beveiligingen in de code en in de netwerkaansluitingen en authorisatie op het netwerk. Ten tweede kan er een team gemaakt worden dat in gevallen van een epi- of pandemie moet beveiligd worden tegen deze ziekte, zodat dit team als back-up kan dienen om de applicatie, eventueel op een lager pitje, kan laten draaien. Voor de laatste twee categorieën kan maar 1 maatregel genomen worden: maak het gebouw waar de server met de database en de applicatie in staat zo brandveilig en sterk mogelijk. Dit om mogelijke natuur- en oorlogsrampen het hoofd te bieden. Een eventuele tweede maatregel die zou kunnen genomen worden om mogelijks nog veiliger te blijven, is een tweede gebouw met opnieuw een server met een kopie van de database en de applicatie te voorzien op een andere plaats als zogezegde back-up.

Punt 3: Noodplan

Als een rampevent gebeurt (zie punt 2) moet er natuurlijk ook een plan op tafel liggen om de applicatie te kunnen blijven gebruiken ondanks dit event.

Ten eerste zal er indien de normaal gebruikte server plat ligt of beschadigd is, de reserveserver opgestart worden en in gebruik genomen worden. Ook de mensen die in deze gebouwen zitten, zullen ruim op tijd uit deze gebouwen worden geëvacueerd. Ten tweede zal er in het geval van een epi- of pandemie het opgestelde team voor deze situatie gecontacteerd worden en aangesteld worden om de applicatie verder te laten draaien, en voor ondersteuning van gebruikers. De sloten/badgelocks van de gebouwen zullen veranderd worden naar de rollen van het reserveteam, en voor iedere in-en uitgang van elk gebouw zal de gemaakte ontsmettingsruimte opengaan om het team te ontsmetten om de anderen niet te besmetten. De temperatuur en andere gezondheidsparameters (ademhaling, hartslag etc.) van deze mensen zullen op drie vaste momenten per dag genomen worden, en van de moment dat deze aantonen dat de persoon ziek is, wordt deze thuis in quarantaine geplaatst worden. Ten derde zal er in het geval van hacking of sabotage direct overgegaan worden op de reserveserver totdat de originele server is hersteld. Er zal dan ook een team van security specialisten worden aangesteld samen met een team developers om het gat, en eventueel andere gaten in de applicatie te vinden, en te dichten

W5: Logging events

4 specifieke events van logging voor in het GiP

Student of Docent heeft ingelogd:

  • Doel: Auditing
  • Event: Gebruiker ingelogd
  • Data: Gebruikersemail – via gekend netwerk/niet – inloggen – locatie – timestamp
  • Locatie van log: in database
  • Zichtbaarheid: Administrator en developer

Administrator heeft ingelogd:

  • Doel: Auditing
  • Event: Admin ingelogd
  • Data: Adminemail – via gekend netwerk/niet – inloggen – locatie – timestamp
  • Locatie van log: in database
  • Zichtbaarheid: Administrator en developer

Administrator heeft Student/Docent aangemaakt:

  • Doel: Auditing + Non-repudation + Geschiedenis
  • Event: Gebruiker aangemaakt
  • Data: Gebruikersgegevens van aangemaakte gebruiker + gebruikersgegevens van admin – via gekend netwerk/niet – gebruiker aangemaakt – locatie – reden aanmaak – timestamp
  • Locatie van log: in database
  • Zichtbaarheid: Administrator en developer

Docent heeft Vak verwijdert:

  • Doel: Non-Repudation
  • Event: Vak verwijdert
  • Data: Gebruikersgegevens van docent – Het vak – Timestamp
  • Locatie van log: in database
  • Zichtbaarheid: Administrator

W4: Authenticatie

In het GiP-Project waar ik aan bezig ben moet er natuurlijk ook authenticatie zitten. Zo moeten docenten natuurlijk meer kunnen dan de studenten, als deze al in de applicatie moeten zijn.

In dit stuk van de blog zal ik laten zien op basis van welke gegevens ik de juiste docenten uit de gebruikers zal halen (Alleen de docenten van UCLL).

Ten eerste vraag ik het e-mail adres van de docent. Aangezien je bij de UCLL moet zitten voor hier ucll in kan staan, kan ik makkelijk kijken of de persoon in kwestie wel effectief bij de UCLL zit.

Ten tweede vraag ik ook de nummer van de docent in zijn grote volledigheid. Dat wil zeggen, als de docent bijvoorbeeld nummer u0012345 heeft, wil ik de “u” erbij. Het lijkt misschien alsof je hier niets mee kan, maar niets is minder waar. Het zijn namelijk alleen docenten die een “u” voor de nummer hebben staan. Als je dus in de ingevulde nummer ziet dat er iets anders voor de nummer staat dan een “u” dan weten we dat het geen docent is.

Ten derde kan ik ook het wachtwoord opvragen van het ingegeven e-mail adres om te checken of het effectief die persoon is. Dit laatste punt is helaas voor het GiP niet te realiseren, en zal ik me dus moeten beperken tot de eerste twee.

Voor de rest vraag ik ook een gebruikersnaam en een wachtwoord om een nieuwe gebruiker te kunnen aanmaken.

W3: Cryptografie

Hier zal ik een aantal stappen doorlopen om cryptografie in Python te doen.

Stap 1: Symmetrische encryptie:

Hier kun je zien hoe encryptie en decryptie werken op een symmetrische wijze met een sleutel om een boodschap te encrypteren aan de hand van een geëncrypteerd wachtwoord:

De code:

from cryptography.fernet import Fernet

key = Fernet.generate_key()
print(“er wordt een sleutel gegenereerd”)
print(key)

print(“nu gaan we met deze sleutel een boodschap encrypteren. We hebben wel eerst een boodschap nodig.”)
print(“onze boodschap \”my deep dark secret\” wordt eerst omgezet naar bytes, dit verstaat de functie wel. Dit doen we met de functie encode()”)
message = “my deep dark secret”.encode()
print(message)
f = Fernet(key)
encrypted = f.encrypt(message)
print(“de geencrypteerde boodschap:”)
print(encrypted)
decrypted = f.decrypt(encrypted)
print(“de gedecrypteerde boodschap”)
print(decrypted)

Het resultaat:

Stap 2: Asymmetrische encryptie:

Hier wordt gebruik gemaakt van een private en een publieke sleutel, die met een bepaald stuk code worden gekozen. De publieke sleutel dient om te encrypteren en de private sleutel om te decrypteren. Dus als je een boodschap verstuurt encrypteer je die eerst met jouw publieke sleutel, en als je er een krijgt decrypteer je de boodschap met jou private sleutel.

De code:

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import serialization
print(“Hier gaan we met private en publieke sleutels werken, meerbepaald het RSA-systeem”)
print(“Eerst gaan we een private sleutel aanmaken.”)
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
backend=default_backend()
)
pem = private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption()
)
print(“De private sleutel”)
print(pem)
print(“Nu gaan we natuurlijk ook een publieke sleutel aanmaken om de boodschap mee te encrypteren”)
print(“De publieke sleutel”)
public_key = private_key.public_key()
pem = public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo
)
print(pem)
print(“Ook hier hebben we weer een boodschap om te encrypteren, hier is dat \”encrypt me!\”. Ook hier gaan we deze boodschap weer voor de functie in bytes omzetten.”)
message = b’encrypt me!’
print(message)
print(“Nu gaan we de boodschap encrypteren”)
encrypted = public_key.encrypt(message, padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))
print(“De boodschap”)
print(encrypted)
print(“Decrypteren moet natuurlijk ook gebeuren, dus laten we dat ook maar doen”)
original_message = private_key.decrypt(encrypted,padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()),algorithm=hashes.SHA256(),label=None))
print(“De originele boodschap”)
print(original_message)

Het resultaat:

Stap 3: Hashen van bestanden en van wachtwoorden

Bij hashen is het, in tegenstelling tot de vorige twee, niet de bedoeling dat we de data terug in de originele vorm gaan terug krijgen. Wat hier wel de bedoeling is, is zeer simpel: de data omzetten naar iets onleesbaar voor het menselijk oog en brein, maar zeer makkelijk leesbaar en controleerbaar voor een computer. Hiermee kun je dataverlies tegengaan.

De code:

import hashlib
print(“Hier wordt een file gehashet”)
file = “C:\temp\LegoTableCopy.txt” #Location of the file
print(“file pad: ” + file)
BLOCK_SIZE = 65536 #The size of each read form the file
print(“Het aantal bytes dat tegelijk wordt uitgelezen: “)
print(BLOCK_SIZE)
file_hash = hashlib.sha256() # Construct a hash object using our selected hashing algorithm
print(“Een hash object aanmaken voor de hash in te zetten”)
print(“Open het bestand”)
print(“Zolang de file niet volledig is uitgelezen, moet het programma blijven lezen en de tekst in hashes omzetten”)
with open(file, ‘rb’) as f: #Open the file to read the bytes
print(“Lees het bestand de eerste keer uit, het aantal bytes staat hierboven vermeld”)
fb = f.read(BLOCK_SIZE) #Read from the file. Take the amount of bytes declared above
while len(fb) > 0: #While there is still data being read from the file
file_hash.update(fb) #Update the hash
print(“Update de hash”)
fb = f.read(BLOCK_SIZE) #Read the next block from the file
print(“Lees opnieuw uit de file”)
print(“De hash:”)
print(file_hash.hexdigest()) #Get the string from the hash

Het resultaat:

Bij wachtwoorden is dit iets moeilijker, omdat je een salt en een key moet maken. De salt is een random gegenereerde combinatie van bytes, en de key wordt berekend aan de hand van het wachtwoord, de salt, en nog een paar andere parameters. Uiteindelijk kan je met de key de key gaan vergelijken van het ingegeven wachtwoord, en de gebruiker binnenlaten als het dezelfde is, of buitenhouden als het niet hetzelfde is.

De code:

import hashlib
import os

print(“Maak een salt en een paswoord”)
salt = os.urandom(32) #Remember this
print(“salt: “)
print(salt)
password = ‘password123’
print(“Paswoord: ” + password)
print(“Maak een sleutel”)
key = hashlib.pbkdf2_hmac(‘sha256’, password.encode(‘utf-8’), salt, 100000)
print(“Sleutel: “)
print(key)
print(“Opslag van de sleutel en de salt voor verificatie achteraf”)
storage = salt + key
file = open(‘storage.txt’, ‘wb’)
file.write(storage)
file.close()
print(“Uitlezen van de sleutel en de salt”)
file2 = open(‘storage.txt’, ‘rb’)
storagefile = file2.read()
file2.close()

saltfile = storagefile[:32]
keyfile = storagefile[32:]

passwordToCheck = ‘password246’
print(“Het wachtwoord dat we moeten checken: ” + passwordToCheck)
newKey = hashlib.pbkdf2_hmac(‘sha256’, passwordToCheck.encode(‘utf-8’), saltfile, 100000)
print(“De sleutel van dit wachtwoord: “)
print(newKey)
print(“Controle of de wachtwoorden (dus de sleutels) hetzelfde zijn”)
if newKey == key:
print(‘Paswoord is correct’)
else:
print(‘Paswoord is incorrect’)

Het resultaat:

Stap 4: Digitale handtekening

Bij een digitale handtekening kun je een standaard bericht dat alleen jij gebruikt, een soort van wachtwoord dus, gebruiken om documenten te ondertekenen. Dit gebeurt ook met een encryptie-algoritme genaamd RSA. Hierdoor is er een asymmetrische encryptie, en is deze dus veiliger om te gebruiken, en even makkelijk om te controleren.

De code:

from Crypto.PublicKey import RSA

keyPair = RSA.generate(bits=1024)
print(f”Public key: (n={hex(keyPair.n)}, e={hex(keyPair.e)})”)
print(f”Private key: (n={hex(keyPair.n)}, d={hex(keyPair.d)})”)

msg = b’A message for signing’
from hashlib import sha512
hash = int.from_bytes(sha512(msg).digest(), byteorder=’big’)
signature = pow(hash, keyPair.d, keyPair.n)
print(“Signature: “, hex(signature))
hashFromSignature = pow(signature, keyPair.e, keyPair.n)
print(“Signature valid: “, hash == hashFromSignature)
msg2 = b’A message for signing (tampered)’
hash = int.from_bytes(sha512(msg2).digest(), byteorder=’big’)
hashFromSignature = pow(signature, keyPair.e, keyPair.n)
print(“Signature valid: “, hash == hashFromSignature)

Het resultaat:

Stap 5: Laten zien van een certificaat

Hieronder zal je een voorbeeld zien van een HTTPS certificaat dat in orde is.

Stap 6: Onderscheppen van boodschappen met HTTP

Het is niet zo moeilijk (als je tenminste weet hoe) om boodschappen te onderscheppen vanuit ZAP om te lezen wat de verschillende boodschappen zijn in leesbare taal. Hier zal ik laten zien hoe.

Eerst moet je de website in ZAP zetten, en draaien.

Dan kun je bijvoorbeeld dit zien:

Hier kun je vanboven zien dat de zoekopdracht gewoon te zien is, en je kunt ook gewoon de data zien die moet meegegeven worden.

W2: AVG (Algemene Verodening gegevensbescherming) Voorbeelden

Bij logging van een applicatie wordt er bijgehouden wat er gedaan is door wie in de applicatie en wordt dan ook vooral gebruikt voor hackers te identificeren. Alleen wordt er ook dan PII-data bijgehouden.

Voorbeelden hiervan zijn in het geval van een hacker de locatie van de hacker en het soort computer van de hacker waar alle instellingen in staan. In het geval van een gewone gebruiker is dit zelfs nog erger: hier wordt niet alleen de locatie en het soort computer bijgehouden, maar ook de identificatie van de gebruiker en zijn privileges.

Voorbeelden van niet PII-data zijn dan weer het proces waar het gebeurd is, en de applicatieversie.

Ziekenhuis

In dit deel gaan we eens kijken op de website van een ziekenhuis (in dit voorbeeld UZ Leuven) of er voorbeelden zijn van verwerking (dit zijn 6 soorten) voor de doeleinden van hun dataverwerking.

Consent:

Dit gaat over het feit dat de gebruiker de toestemming geeft om zijn gegevens te verwerken na duidelijk geïnformeerd te zijn. In het Ziekenhuis voorbeeld is het patiëntendossier een mooi voorbeeld. Er staat duidelijk dat er pas een patiëntendossier wordt aangemaakt en kan worden verwerkt als u daar uitdrukkelijk toestemming voor geeft. Ook staat er wie het dossier kan bekijken en kan aanpassen. Er staat zelfs een duidelijk menu van hoe u zelf bepaalde instanties toegang kunt weigeren via links.

Contract:

Dit gaat over het feit dat u eerst een invulformulier moet invullen voor ze uw gegevens kunnen en mogen verwerken. In het ziekenhuis voorbeeld is dit het geval, en het staat zelfs in het privacyreglement van het ziekenhuis. Er staat bijvoorbeeld ook in dat ze uw gegevens pas op andere manieren mogen verzamelen als u het formulier niet kunt invullen, bijvoorbeeld als u bewusteloos bent, of als het doel van de verwerking dat nodig acht, bijvoorbeeld als ze een XRay-foto moeten nemen om info over uw inwendige toestand te meten.

Legal Obligation:

Dit gaat over het feit dat de verwerker bij wet verplicht moet zijn om die gegevens te verzamelen. In het ziekenhuis voorbeeld is dit geval, aangezien een ziekenhuis de wettelijke verplichting heeft om al haar patiënten zo goed mogelijk te helpen met alleen de nodige info voor de nodige hulp.

Vital Interests:

Dit gaat over het feit dat de verwerker de gegevens alleen mag verwerken om vitale belangen te vervullen. In dit ziekenhuis voorbeeld zie je dat continu, aangezien zij patiënten helpen met alle soorten van aandoeningen, gaande van ernstige bloedingen door een ongeval, tot zelfs het opereren van mensen om tumoren weg te halen. Hiervoor moeten ze uiteraard persoonlijke gegevens verwerken.

Public Task:

Dit gaat over het feit dat de verwerker eerst een algemeen nut moet vervullen voor ze uw gegevens in het verband met dat nut mogen verwerken. In dit ziekenhuis voorbeeld is dit het geval aangezien ze in een ziekenhuis aan onderzoeken doen bij mensen over bepaalde ziektes en behandelingen. Hiervoor hebben ze ook persoonlijke gegevens nodig, die ze in dat geval ook alleen daarvoor gebruiken.

Legitimate Interests:

Dit gaat over het feit dat de verwerker een gerechtvaardigd belang te verdedigen van een derde of van de verwerkingsverantwoordelijke op voorwaarde dat het belang van de persoon van wie de gegevens zijn niet zwaarder doorwegen. In dit ziekenhuis voorbeeld is dit het geval met het patiëntendossier, aangezien dat dit wordt doorgegeven aan de huisarts van de patiënt zodat deze ook de belangrijke medische info van de patiënt ter beschikking heeft.

Maak je eigen website, gratis op WordPress.com.Maak je eigen website
Start gratis