Wachtwoord onleesbaar opslaan (versleutelen, ontsleutelen)

Wachtwoord-check

Crypt

Er bestaat een Gambas bibliotheek (component) voor wachtwoord versleuteling en checken van een wachtwoord:

Crypt

De Crypt klasse levert : Check DES MD5 SHA256 SHA512

Hiermee kan je een wachtwoord versleutelen met DES of MD5, algoritmes uit de GNU libc bibliotheek.

ps: Zoals in Linux gebruikt, op de commandolijn met md5sum abc.txt om de checksum van (download) bestand abc.txt te krijgen.

Je kan ook de checksum van een gegeven wachtwoord vergelijken met de opgeslagen checksum van een eerder gegeven wachtwoord (waarbij je dat origineel wachtwoord niet opslaat, maar enkel de checksum); als die klopt is het gegeven wachtwoord juist.

Versleutel-ontsleutel

OpenSSL

Er is ook een bibliotheek die toelaat tekst te versleutelen en ontsleutelen (IDE-menu Project, Properties, Components): gb.openssl
OpenSSL levert:

  • Cipher de cipher (block en stream) algoritmes van OpenSSL. Wikipedia: Ciphers.
  • CipherText
  • Digest de hash algoritmes van het OpenSSL project. Wikipedia: Cryptographic hash function
  • HMac op hash gebaseerde berichten-toegangscodering (HMAC). Wikipedia: HMAC

Algoritmes

Er bestaan verschillende versleutelalgoritmes (en “operation modes”), en je kan die na het kiezen van de openssl library ook opvragen.
Maak een nieuw leeg project in Gambas3 (misschien werkt het ook in 2), en in de MMain vul je onderstaande code in.
Die toont op de commandolijn alle aanwezige algoritmes, en bewaart ze ook in een bestand (~/.config/gambas3/CipherList.conf)

CipherList

Private sName As String
Private icount As Integer

Public Sub Main()
  Settings["Cipher/date"] = Str$(Now())
  For Each sname In Cipher.List.Sort()
    Print sName; "\n";
    Settings["Cipher/" & Str$(icount)] = sName
    Inc icount
  Next
  
End

Je krijgt een lijst van bv 89 mogelijkheden (zie lijst onderaan); ze bestaan uit de encryptiemethode (plus bit-sterkte) en een “mode”, bv CBC staat voor Cipher Block Chaining (zie hieronder “operation mode” *).

Enkele algoritmen uit de lijst:

  • AES-128-CBC staat eerste in de lijst, gebruikt in dit vb.
  • BlowFish (Schneier) is veelgebruikt, maar ondertussen door hem als verouderd beschouwd (zie twofish).
  • DES=Data Encryption Standard: werd bekend om zijn korte sleutel, gedeeltelijke geheimhouding en betrokkenheid van NSA.
  • AES=Advanced Encryption Standard: Rijndael (ontwikkeld door twee Belgen: V. Rijmen & J. Daemen): opvolger van DES (Amerikaanse standaard). AES-128 wordt nog steeds als veilig gezien (2006).
  • , en spijtig genoeg niet in de lijst: twofish.

Je hebt de letterlijke tekstwaarde van de gekozen methode nodig om het algoritme op te roepen in je programma.

* Operation mode
Bepaalt op welke manier het oorspronkelijk te versleutelen bericht benaderd wordt voor versleuteling.
De “mode” wordt aangegeven door de extra lettercombinatie achteraan:

  • ECB=Electronic CodeBook: bericht wordt in stukjes gekapt, elk stuk versleuteld. Zwakte: patronen worden zichtbaar! (vgl elke letter apart versleutelen; patroon van de “e” wordt zichtbaar)
  • * CBC=Cipher Block Chaining: er wordt op iedere blok een bewerking gedaan tov het vorige blok, en een initialisatie vector moet gebruikt worden voor het eerste blok. De-cryptie kan parrallel, en Random Read Acces is mogelijk.
  • * CTR=CounTeR of ICM=Integer Counter Mode of SIC=Segmented Integer Counter: maakt van een block cipher een stream cipher. En+De-cryptie kan parrallel, en Random Read Acces is mogelijk.
  • PCBC=Propagating Cipher Block Chaining: gebruikt ook initialisatievector.
  • CFB=Cipher Feedback

* aanbevolen methode door o.a. Bruce Schneier (van Schneier on Security)

Meer info zie wikipedia Block_cipher_mode_of_operation

Tekst versleutelen – ontsleutelen

Het volgende stukje programma kan je toevoegen aan het vorige, het geeft een encryptie en decryptie van “Geheim”:

  Print Cipher["AES-128-CBC"].Encrypt("Geheim")
  Print Cipher["AES-128-CBC"].Decrypt(Cipher["AES-128-CBC"].Encrypt("Geheim"))

Het resultaat:

(CipherText 0x1ce7cf8)
Geheim

Meestal zal je de encrypt en decrypt niet in één regel gebruiken, en gebruik je een variabele, en dat is hier geen eenvoudige tekst (string).
Om die te declareren heb je de speciale variabele uit Cipher nodig:

Private hEncrypted As CipherText

En de code met encrypt naar variabele, en apart decrypt:

  hEncrypted = Cipher["AES-128-CBC"].Encrypt("Geheim")
  Print hEncrypted
  Print Cipher["AES-128-CBC"].Decrypt(hEncrypted)

De encryptie-methode steek je in een constante, bv PRIVATE Const sEncryptmethod AS String = “AES-128-CBC”.
In de code hier net boven ontbreken trouwens nog de Key en de InitVector.

Versleutelde tekst in bestand

In het geval dat de versleutelde tekst in een bestand zit, en daarnaar geschreven + daaruit gelezen moet worden, kan het hetvolgende programma gebruiken:

' Gambas module file

Private hEncrypted As CipherText
Private sLine As String
Private sCryptedFile As String
Private Const sAlgorithm As String = "AES-128-CBC"
Private sKey As String ' 32 ??
Private sInitVector As String ' 16


Public Sub Main()

  Print "Hello cipher world 2" ' 
  sCryptedFile = User.Home &/ "cipher.bin"
  hEncrypted = Null
  ' can be asked from user:
  
  sKey = "123456789012345678901234567890123"
  sInitVector = "1234567890123ABC"

  Print "Geef een woord of tekst (einde met enter):"
  Line Input sLine

  Try hEncrypted = Cipher[sAlgorithm].Encrypt(sLine, sKey, sInitVector)
  If Error
    Print Error.Text & " with key " & sKey
    TestKeyLength() 
  Endif

  File.Save(sCryptedFile, hEncrypted.Cipher)

  Print Base64$(File.Load(sCryptedFile))
  
  sLine = ""
  Print "I Decrypt " & sCryptedFile & " as : " 
  ' sLine = Cipher["AES-128-CBC"].Decrypt(File.Load(sCryptedFile))
  ' TYPE Mismatch, wanted CipherText, got String instead
  ' split up:
  hEncrypted = New CipherText(File.Load(sCryptedFile), sKey, sInitVector)
  ' now it seems we have to use the key and initvector, even if not required to encrypt ...
  
  sLine = Cipher[sAlgorithm].Decrypt(hEncrypted)
  Print sLine 
  
End

Print Base64$ maakt het een beetje leesbaar op de console zonder dat er rare dingen gebeuren; je kan ook het bestand gaan bekijken met bv kwrite, en daar zal het er helemaal anders uitzien…

€Íÿ‚Æ&ÜáÒ²ÆŠÀ9ÿáUÿ2†ŒúKüۖ

De sleutel

Het volgende probleem is: hoe bepaal je de key? Hoe lang moet die zijn? Theorie buiten beschouwing gelaten kan je het zelf uitzoeken op jouw systeem met deze proefondervindelijke methode:

  
Public Sub TestKeyLength()

  Dim sKeyShorter As String
  
  sKeyShorter = "123456789012345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  While (Len(sKeyShorter) > 1)
    sKeyShorter = Left(sKeyShorter, -1)
    Try hEncrypted = Cipher[sAlgorithm].Encrypt(sLine, sKeyShorter, sInitVector)
    If Not Error
      Print "no error at keylength: " & Str(Len(sKeyShorter))
      Exit
    Else
      Print "Err with: " & sKeyShorter & " " & Len(sKeyShorter)
    Endif
  Wend

End

Het resultaat in mijn console:

Hello cipher world 2
Geef een woord of tekst (einde met enter):
Gambas3 really rocks!
Key length does not match method with key 1234567890123456789012345
67890123
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXY 5
5
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNOPQRSTUVWX 54
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNOPQRSTUVW 53
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNOPQRSTUV 52
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNOPQRSTU 51
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNOPQRST 50
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNOPQRS 49
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNOPQR 48
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNOPQ 47
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNOP 46
Err with: 123456789012345678901234567890ABCDEFGHIJKLMNO 45
Err with: 123456789012345678901234567890ABCDEFGHIJKLMN 44
Err with: 123456789012345678901234567890ABCDEFGHIJKLM 43
Err with: 123456789012345678901234567890ABCDEFGHIJKL 42
Err with: 123456789012345678901234567890ABCDEFGHIJK 41
Err with: 123456789012345678901234567890ABCDEFGHIJ 40
Err with: 123456789012345678901234567890ABCDEFGHI 39
Err with: 123456789012345678901234567890ABCDEFGH 38
Err with: 123456789012345678901234567890ABCDEFG 37
Err with: 123456789012345678901234567890ABCDEF 36
Err with: 123456789012345678901234567890ABCDE 35
Err with: 123456789012345678901234567890ABCD 34
Err with: 123456789012345678901234567890ABC 33
Err with: 123456789012345678901234567890AB 32
Err with: 123456789012345678901234567890A 31
Err with: 123456789012345678901234567890 30
Err with: 12345678901234567890123456789 29
Err with: 1234567890123456789012345678 28
Err with: 123456789012345678901234567 27
Err with: 12345678901234567890123456 26
Err with: 1234567890123456789012345 25
Err with: 123456789012345678901234 24
Err with: 12345678901234567890123 23
Err with: 1234567890123456789012 22
Err with: 123456789012345678901 21
Err with: 12345678901234567890 20
Err with: 1234567890123456789 19
Err with: 123456789012345678 18
Err with: 12345678901234567 17
no error at keylength: 16
gM3/gsYm3OEC0g+ygcaKwDn/4VX/Mg6GjPqQS/zblgo=
I Decrypt /home/cybr/cipher.bin as : 
Gambas3 really rocks!

Dus in plaats van de 32 tekens voor de key, elders vermeld in literatuur, heb ik hier 16 nodig.

Ik kan aan mijn programma’s een tekstbestand leveren met een versleutelde toegangscode voor de databank.
Wie het bestand leest kan er niets mee. Wie het programma ontleedt wel als de sleutel en initvector (of salt) vast in de broncode staan.


De hele lijst van mogelijke algoritmes:
Continue reading

Foutenbeheer en log via Error klasse

Ik wil in mijn programma:

  • een vaste manier om met foutmeldingen te werken
  • nadien de foutmeldingen kunnen nazien

In allerlei Classes, Modules en Forms kunnen fouten ontstaan, ik hou altijd de laatste ter plaatse bij in een variabele sLastError.


PRIVATE sLastError AS String

PUBLIC SUB getLastError() AS String
  
  RETURN sLastError
  
END

In mijn FMain heb ik een procedure waar ik alle foutmeldingen naartoegooi:

FMain


PUBLIC SUB SetError(sTextline AS String) 
  
  lsbxError.Add(Str$(iErrCounter) & ": " & sTextline, MCommon.insertTop)
  IF MMain.bErrorFile 
    MMain.hError.writeError(Str$(iErrCounter) & ": " & sTextline)
  ENDIF 
  INC iErrCounter
  
END

Fouten zakken weg naar onder in het zichtbaar meldingen-schermdeel in de toepassing, de ListBox lsbxError.
De constante in MCommon die aangeeft dat bovenaan in de lijst wordt toegevoegd is misschien wat overdreven:

MCommon

PUBLIC CONST insertTop AS Integer = 0

In MMain heb ik mijn error object, wat alle foutmeldingen opvangt:

MMain

... 
hError = NEW CError  
  IF hError.sLastError
    bErrorFile = FALSE
    sLastError = "Error handling to file: " & hError.sLastError
  ELSE 
    bErrorFile = TRUE
  ENDIF 
...

Mijn foutklasse heet CError:

CError

PRIVATE $hErrorFile AS File
PUBLIC sLastError AS String
PRIVATE sErrorFileName AS String


PUBLIC SUB _new(OPTIONAL sFileName AS String)
  
  IF sFileName
    sErrorFileName = sFileName
    openErrorFile(sErrorFileName)
  ELSE 
    sErrorFileName = System.User.Home & "/.config/gambas" & "/" & Application.Name & "-error.txt"
    DEBUG sErrorFileName
    openErrorFile(sErrorFileName)
  ENDIF 
  
END

PUBLIC SUB getErrorFileName() AS String
  
  RETURN sErrorFileName

END


PUBLIC SUB openErrorFile(sErrorFile AS String) AS Boolean
  
  IF Exist(sErrorFile)
    'TRY $hErrorFile = OPEN sErrorFile FOR WRITE APPEND ' cannot append without maintenance
    TRY $hErrorFile = OPEN sErrorFile FOR WRITE CREATE  
  ELSE 
    TRY $hErrorFile = OPEN sErrorFile FOR WRITE CREATE 
  ENDIF 
  
  IF ERROR 
    sLastError = Error.Text
    RETURN FALSE
  ELSE 
    writeError("*** CError uses file: " & sErrorFileName)
    writeError("*** on: " & System.Host & " " & System.User.Name & " " & Application.Name & " " & Application.Version & " from " & Application.Path)
    sLastError = ""
    RETURN TRUE
  ENDIF 
  
END

PUBLIC SUB closeErrorFile()
  
  TRY CLOSE $hErrorFile
  TRY $hErrorFile.Close()
  
END


PUBLIC SUB writeError(sErrorText AS String) AS Boolean
  
  TRY PRINT #$hErrorFile, Date & "@" & Time & ":" & sErrorText
  IF ERROR 
    RETURN FALSE
  ELSE 
    RETURN TRUE
  ENDIF 
  
END

Upd 2018-04: ondertussen iets aangepaste versie:

' Gambas class file

' CError - help with formatting for display and storing to an error log

Public bLogToFile As Boolean

Private sPreviousError As String
Private sLastError As String
Private SErrorText As String

Private $hErrorFile As File
Private iErrorCount As Integer

Public Sub _new()
  
  Dim s As String
  
  ' rotate error log file
  If Exist(getErrorFileName() & "~")
    Try Kill getErrorFileName() & "~"
  Endif
  Try Copy getErrorFileName() To getErrorFileName() & "~"
  Try $hErrorFile = Open getErrorFileName() For Write Create
  If Not Error
    bLogToFile = True
    Exec ["gambas3", "-V"] To s
    s = "Error file for " & Application.Name & " " & Application.Version & " for " & System.User.Name & "@" & System.Host & ", gambas " & s
    Print #$hErrorFile, s 
    Print #$hErrorFile, " ----------------------------------------------------------------------------------------" 
    Try Close $hErrorFile
  Else
    Debug "try to open error file " & getErrorFileName() & ": " & Error.Text
    bLogToFile = False
  Endif
  iErrorCount = 0
  
End

Public Sub getErrorFileName() As String
  
  If Not Exist(System.User.Home &/ ".local/log")
    Mkdir System.User.Home &/ ".local/log/"
  Endif
  Return System.User.Home &/ ".local/log/" & Application.Name & "-err.txt"
  
End

Public Sub shiftError(sNewError As String)
 
  sPreviousError = sLastError
  sLastError = Stamp(sNewError)

End



Public Sub Stamp(s As String) As String
  
  Return Now() & ";" & Str(iErrorCount) & ": " & s
  
End


Public Sub setError(sError As String, Optional bForceLogToFile As Boolean) As String
  
  SErrorText = sError
  Inc iErrorCount
  shiftError(sError)
  If (bForceLogToFile Or bLogToFile)
    LogToFile(sLastError)
  Endif
  Return iErrorCount & " " & sError & " @" & Time(Now())
  
End


Public Sub getPreviousError() As String
  
  Return sPreviousError
  
End

Public Sub LogToFile(s As String)
  
  Try $hErrorFile = Open getErrorFileName() For Write Append
  If Error
    Debug Error.Text
  Endif
  Try Print #$hErrorFile, s
  If Error 
    Debug Error.Text
  Endif
  Try Close $hErrorFile
  If Error
    Debug Error.Text
  Endif
  
End

Versienummer onderhouden

Een Gambas programma heeft een versienummer dat bestaat uit x.x.x, bv 0.0.1 als je net een nieuw project gestart hebt.
Het is in de IDE zichtbaar in Project, properties, en kan daar ook aangepast worden. Het wordt automatische verhoogd als je “compile” doet in de IDE. In code kan je het opvragen met Application.Version.

In een programma dat een databank gebruikt, hou ik ook bij welke versie lokaal geïnstalleerd staat, en wat de vorige versie was. Dat kan helpen in het oplossen van problemen, bv op het moment dat de struktuur van de databank verandert, en je dus zeker moet zijn met welke versie je werkt. Eigenlijk zou ik ook in de databank de minimumversie moeten bewaren bedenk ik nu, of misschien zelfs loggen user_id, version_used.

Ik heb geprobeerd zicht te houden op de versies die lokaal gebruikt worden, opgeslagen in de Settings File (~/.config/gambas/application.conf):

application.conf

[General]
..
Language="nl_BE"
Runcounter=1028
..
PreviousVersion="0.2.38"
LastVersion="0.2.38"
Version="0.2.38"
HighVersion="0.2.39"
LowVersion="0.2.10"
PreVersionDateOut=07/01/2016 13:24:07.426
...

Ik kan aflezen wat de laagste gebruikte versie is, wat de hoogste (soms schakel je terug naar een lagere versie na vastgestelde fouten bv), wat de huidige, voorgaande en wat de laatst gebruikte versie was.

Waarvoor ik in de module MCommon:


PRIVATE sLastError AS String

PUBLIC SUB storeVersion()
  ' check version settings exist
  IF NOT Settings["General/PreviousVersion"]  ' previous version number used (lower)
    Settings["General/PreviousVersion"] = Application.Version 
  ENDIF 

  IF NOT Settings["General/LowVersion"] ' lowest version used 
    Settings["General/LowVersion"] = Application.Version
  ENDIF 
 
  IF NOT Settings["General/HighVersion"] ' highest version used - kept when downgrading!
    Settings["General/HighVersion"] = Application.Version
  ENDIF 
  
  Settings["General/LastVersion"] = Settings["General/Version", ""] ' first save value before replacing it
  Settings["General/Version"] = Application.Version ' store version of current run 
  
  IF (Settings["General/Version"] <> Settings["General/LastVersion"]) ' up or downgrade?
    IF newestVersion(Settings["General/LastVersion"], Settings["General/Version"]) = Settings["General/Version"] ' upgrade
      Settings["General/PreVersionDateOut"] = Now() 
      Settings["General/PreviousVersion"] = Settings["General/LastVersion"]
      
    ELSE ' downgrade, check under lowest ?
      IF newestVersion(Settings["General/LowVersion"], Application.Version) = Settings["General/LowVersion"]
        Settings["General/LowVersion"] = Application.Version
      ENDIF 
    ENDIF 
    IF Settings["General/HighVersion"] <> Application.Version
      Settings["General/HighVersion"] = newestVersion(Settings["General/HighVersion", ""], Application.Version)
    ENDIF 
    
  ENDIF 
  Settings.Save

END

met de test :

PUBLIC FUNCTION newestVersion(sVersionA AS String, sVersionB AS String) AS String
  
  DIM sPart AS String
  
  DIM arrsPartsA AS String[]
  DIM arrsPartsB AS String[]
  
  DIM i AS Integer
  
  IF NOT sVersionA ' sVersionA is empty
    IF sVersionB 
      RETURN sVersionB
    ELSE ' AND sVersionB is empty
      RETURN ""
    ENDIF 
  ELSE IF NOT sVersionB ' sVersionB is empty
    RETURN sVersionA
  ELSE ' none is empty; compare parts to find out
    arrsPartsA = Split(sVersionA, ".")
    arrsPartsB = Split(sVersionB, ".")
  
    IF arrsPartsA.Count = arrsPartsB.Count
  
      FOR i = 0 TO (arrsPartsA.Count - 1)
        IF Val(arrsPartsA[i]) > Val(arrsPartsB[i])
          RETURN sVersionA
        ELSE 
          IF Val(arrsPartsB[i]) > Val(arrsPartsA[i])
            RETURN sVersionB
          ELSE 
            sLastError = "Part " & Str$(i + 1) & " of version number is the same " & arrsPartsA[i]
            DEBUG sLastError
          ENDIF 
        ENDIF 
        
      NEXT 
    ELSE 
      sLastError = "Could not detect versions; structure not the same: " & sVersionA & " <> " & sVersionB
      RETURN ""
    ENDIF 
    
  ENDIF   
  
END

en aangeroepen vanuit de eerst opstartende module, bv de klasse MMain (die opstartklasse is en nadien FMain aanroept):

MMain


 MCommon.storeVersion()

Inleiding tot Gambas – PostgreSQL

Ik probeer het voorbeeld van dit artikel op Linux Journal na meer dan 10 jaar uit met één van de volgende versies van Gambas (3.x) en een andere databank die meer verschilt dan MySQL-MariaDB onderling: PostgreSQL.
Hier de beschrijving die gaat tot het ophalen en weergeven van gegevens (dus niet heel artikel uitgewerkt).

Vertrek van een Linux desktop systeem, met Gambas en PostgreSQL geïnstalleerd.
Het concept van het artikel is een soort summiere bug-tracker te maken.

Gambas IssueTracker
Start Gambas 3.9.x, new project, Database application.
– Je krijgt een lege FMain bij de “sources”.

Maak een knop om de applicatie te sluiten: kies onderaan rechts de “ok” knop uit de “Form” tab iconen, plak hem ergens op het scherm
– op het scherm staat een knop met “ok” erop.

Wijzig de tekst op de knop:
In de tab “Properties” rechts zie je een invulbaar veld naast “Text”; zet daar “Sluiten”.
– De knop op het scherm krijgt aangepaste tekst.
Zet helemaal bovenaan bij Name in plaats van Button1: btQuit

Wijzig de code van de knop:
Dubbelklik op de knop en je komt in de tekstbewerker. Tik tussen de begin en eindcode van de druk-op-de-knop procedure (die hij voor je klaarzet): Me.Close()
Samen ziet het er zo uit:

Public Sub btQuit_Click
  Me.Close()
End

Terwijl je op de run knop in de knoppenbalk van Gambas3 drukt (of F5 op je toetsenbord), weet je dat je een leeg venster op het scherm gaat zien met één knop: “Sluiten”. Je kan je niet bedwingen om op die knop te klikken.

Pauze om na te denken
Het oorspronkelijke artikel vermeldt volgende noden:

  • nieuw probleem melden
  • bijhouden wie het probleem meldde
  • probleem als opdracht toewijzen aan programmeur
  • de toestand van het probleem beheren
  • bijhouden wanneer het probleem werd gemeld
  • bijhouden in welke programmaversie het probleem is opgelost
  • overzicht krijgen van nieuwe problemen, problemen waar aan gewerkt wordt, en opgeloste problemen

Meer gedetailleerd hebben we nodig:

  • identificatie van de melder
  • identificatie van de oplosser
  • beschrijving van het probleem

Nog meer gedetailleerd:

  • gegevens van de melder: id, name
  • gegevens van de oplosser: id, name
  • details van het probleem: id, beschrijving, datum in, door wie aangebracht en opgelost, applicatie waarover ze gaat, versienummer van vaststelling probleem en oplossing

Databank

Om databank-layout uit te proberen is phpPgAdmin leuk, maar nadien weet je waarschijnlijk niet meer wat je juist gedaan hebt.
Het is handig om de databank aan te maken vanuit een bestand, zodat je met dat bestand gegarandeerd dezelfde databank kan maken.
(of je draait het om; maak in phpPgAdmin, en exporteer de vorm naar een bestand)

In MySQL/MariaDB was het zoiets:

Continue reading