Symmetric_Block_cipher_solutions_extract.pdf

# Berekening van een blokcijfer Dit gedeelte beschrijft de componenten en stappen van een eenvoudig blokcijfer, vergelijkbaar met AES, dat een S-box substitutie, een permutatie en een XOR-operatie met de sleutel omvat [1](#page=1). ### 1.1 Algemene principes van het blokcijfer Een eenvoudig blokcijfer wordt beschreven met een blokgrootte van 128 bits en bestaat uit slechts één ronde. De opeenvolgende bewerkingen binnen deze ronde zijn [1](#page=1): 1. Een S-box substitutie [1](#page=1). 2. Een permutatie van de bytes [1](#page=1). 3. Een XOR-operatie met de sleutel [1](#page=1). ### 1.2 Componenten van het blokcijfer #### 1.2.1 De S-box De S-box fungeert als een substitutietabel die wordt gebruikt om bytes te vervangen. Voor de specifieke oefening is de S-box als volgt gedefinieerd [1](#page=1): `eefc5afcc8fcc7fc79fc82fcd9fc52fc` [2](#page=2). #### 1.2.2 De permutatie De permutatie herschikt de bytes binnen het blok volgens een gegeven sequentie. De sequentie voor de permutatie van de 128 bits is: ` `. Dit betekent dat de byte op positie $i$ naar de positie $p_i$ in de sequentie wordt verplaatst. Bijvoorbeeld, de eerste byte (meest links) gaat naar positie 15 (meest rechts), en de tweede byte van links gaat naar positie 0 (meest links) [1](#page=1) [2](#page=2) [3](#page=3) [4](#page=4) . > **Tip:** De Python `permute` functie kan zowel met gehele getallen (integers) als met byte strings werken, en beide varianten geven hetzelfde resultaat. Bij het werken met gehele getallen, zorg ervoor dat je het aantal hexadecimale symbolen correct interpreteert, waarbij een oneven aantal symbolen kan impliceren dat een voorloopnul ontbreekt voor een correcte byte-representatie. Bij nieuwe Python-implementaties wordt de voorkeur gegeven aan byte strings [3](#page=3). #### 1.2.3 De sleutel De gebruikte sleutel voor de encryptie is: `0x1032547698BADCFE1032547698BADCFE` [1](#page=1). ### 1.3 Berekening van het cipherblok: een oefening Gegeven de volgende input, sleutel en permutatiesequentie, bereken het resulterende cipherblok. * **Input:** `0x01002300450067008900AB00CD00EF00` [1](#page=1). * **Sleutel:** `0x1032547698BADCFE1032547698BADCFE` [1](#page=1). * **S-box:** `eefc5afcc8fcc7fc79fc82fcd9fc52fc` [2](#page=2). * **Permutatiesequentie:** ` ` [1](#page=1) [2](#page=2) [3](#page=3) [4](#page=4) . **Stappen:** 1. **S-box substitutie:** Pas de S-box toe op elke byte van de input. * Input bytes: `01`, `00`, `23`, `00`, `45`, `00`, `67`, `00`, `89`, `00`, `AB`, `00`, `CD`, `00`, `EF`, `00`. * Na S-box substitutie (afhankelijk van de S-box definitie): * `01` wordt `ef` * `00` wordt `fc` * `23` wordt `82` * `00` wordt `fc` * `45` wordt `fc` * `00` wordt `fc` * `67` wordt `c8` * `00` wordt `fc` * `89` wordt `fc` * `00` wordt `fc` * `AB` wordt `fcc` * `00` wordt `fc` * `CD` wordt `52` * `00` wordt `fc` * `EF` wordt `fc` * `00` wordt `fc` * Resultaat na S-box: `ef fc 82 fc fc fc c8 fc fc fc fcc fc 52 fc fc fc` 2. **XOR met de sleutel:** XOR de output van de S-box met de sleutel. * Input na S-box: `0xef008200fcfc00c8000000fcfc52fcfc` (Let op: hier is de byte `00` van de input als input voor de S-box gebruikt, en de S-box resultaten zijn dan direct naast elkaar geplaatst. De correcte stap is per byte) * Correcte S-box output: `ef fc 82 fc fc fc c8 fc fc fc fc fc 52 fc fc fc` * Sleutel: `10 32 54 76 98 BA DC FE 10 32 54 76 98 BA DC FE` * Berekening (byte per byte): * `ef` XOR `10` = `ff` * `fc` XOR `32` = `ce` * `82` XOR `54` = `d6` * `fc` XOR `76` = `80` * `fc` XOR `98` = `64` * `fc` XOR `ba` = `46` * `c8` XOR `dc` = `14` * `fc` XOR `fe` = `02` * `fc` XOR `10` = `ec` * `fc` XOR `32` = `ce` * `fc` XOR `54` = `a8` * `fc` XOR `76` = `80` * `52` XOR `98` = `c4` * `fc` XOR `ba` = `46` * `fc` XOR `dc` = `14` * `fc` XOR `fe` = `02` * Resultaat na XOR: `0xffce d6 80 64 46 14 02 ec ce a8 80 c4 46 14 02` 3. **Permutatie:** Pas de permutatie toe op de output van de XOR-stap. * Input voor permutatie: `0xffced68064461402eca880c4461402` * Permutatiesequentie: ` ` [1](#page=1) [2](#page=2) [3](#page=3) [4](#page=4) . * De byte op positie 0 (`ff`) gaat naar positie 15. * De byte op positie 1 (`ce`) gaat naar positie 0. * De byte op positie 2 (`d6`) gaat naar positie 14. * Enzovoort. * De bytes worden geordend volgens de permutatiesequentie: * Positie 0: byte van input pos 1 (`ce`) * Positie 1: byte van input pos 3 (`80`) * Positie 2: byte van input pos 5 (`46`) * Positie 3: byte van input pos 7 (`02`) * Positie 4: byte van input pos 9 (`ce`) * Positie 5: byte van input pos 11 (`80`) * Positie 6: byte van input pos 13 (`46`) * Positie 7: byte van input pos 15 (`02`) * Positie 8: byte van input pos 14 (`14`) * Positie 9: byte van input pos 12 (`c4`) * Positie 10: byte van input pos 10 (`a8`) * Positie 11: byte van input pos 8 (`ec`) * Positie 12: byte van input pos 6 (`14`) * Positie 13: byte van input pos 4 (`64`) * Positie 14: byte van input pos 2 (`d6`) * Positie 15: byte van input pos 0 (`ff`) * Resulterend cipherblok: `ce804602cea880c41464d6ff` > **Example:** Als we een inputblok $b = b_0 b_1 b_2 b_3 b_4$ hebben en een permutatiesequentie $s = $, dan is het permuteerde blok $b' = b_{s_0} b_{s_1} b_{s_2} b_{s_3} b_{s_4}$. Met $s = $ wordt dit $b' = b_3 b_2 b_4 b_1 b_0$ [1](#page=1) [2](#page=2) [3](#page=3) [4](#page=4). ### 1.4 Variaties van de vraag De vraag kan worden uitgebreid met verschillende scenario's [4](#page=4): * **Twee blokken:** Als er twee blokken van input zijn, hoe wordt dit dan verwerkt? [4](#page=4). * **ECB (Electronic Codebook):** Hoe zou de encryptie verlopen met ECB-modus? [4](#page=4). * **CBC (Cipher Block Chaining):** Hoe zou de encryptie verlopen met CBC-modus, met een gegeven initialisatievector (IV)? [4](#page=4). * **CTR (Counter Mode):** Hoe zou de encryptie verlopen met CTR-modus, met gegeven tellerwaarden? [4](#page=4). > **Tip:** Voor decryptie is de inverse S-box nodig. Deze kan expliciet gegeven zijn, of men kan uitgaan van een S-box en de bijbehorende inverse S-box. Het is ook mogelijk dat er twee blokken zijn, wat afgeleid kan worden uit de blokgrootte en de lengte van de input [4](#page=4). --- # Permutatie operatie De permutatie operatie is een proces waarbij de volgorde van elementen binnen een sequentie wordt gewijzigd volgens een gespecificeerde ordening. Deze operatie kan worden toegepast op zowel gehele getallen (representaties van binaire data) als op byte-strings [1](#page=1) [3](#page=3). ### 2.1 Werking van de permutatie operatie De kern van de permutatie operatie ligt in het verplaatsen van bytes (of delen van een getal) naar nieuwe posities. Een permutatiesequentie definieert de nieuwe plaatsing van elk byte-element [1](#page=1). #### 2.1.1 Permutatie met gehele getallen Wanneer de permutatie operatie wordt toegepast op een geheel getal, worden de bytes die het getal vormen, herverdeeld volgens de gegeven volgorde. De positieaanduidingen zijn doorgaans gebaseerd op een indexering, waarbij bijvoorbeeld positie 0 de meest rechtse positie kan zijn en de hoogste index de meest linkse [1](#page=1) [3](#page=3). > **Voorbeeld:** > Als we een getal $b = 0x1234567890$ hebben en de permutatiesequentie $s = $, betekent dit dat de eerste byte ($0x12$) naar positie 3 gaat, de tweede byte ($0x34$) naar positie 2, enzovoort. De exacte interpretatie van de posities (links/rechts) is cruciaal voor het correct toepassen van de permutatie [1](#page=1) [2](#page=2) [3](#page=3) . #### 2.1.2 Permutatie met byte-strings De permutatie operatie kan ook direct worden toegepast op byte-strings. Dit is vaak een meer expliciete en soms duidelijkere manier om de data te manipuleren, omdat de individuele bytes direct zichtbaar zijn [3](#page=3). > **Voorbeeld:** > Gegeven een 128-bits sequentie die byte-voor-byte wordt behandeld, en een permutatiesequentie zoals $ $. Dit betekent dat de eerste byte van de input (geïndexeerd als 0) naar de 15e positie van de output gaat, de tweede byte (geïndexeerd als 1) naar de 0e positie van de output gaat, enzovoort [1](#page=1) [2](#page=2) [3](#page=3) . #### 2.1.3 Implementatieoverwegingen Bij de implementatie van de permutatie operatie is het belangrijk om rekening te houden met hoe de data wordt gerepresenteerd (geheel getal of byte-string). Moderne implementaties, zoals in de Python code van het cursusmateriaal, geven de voorkeur aan byte-strings voor duidelijkheid [3](#page=3). Er zijn twee gangbare manieren om hexadecimale data om te zetten naar bytes: 1. Door het hexadecimale getal eerst te interpreteren als een integer en die vervolgens om te zetten naar bytes [3](#page=3). 2. Door direct een byte-string te creëren vanuit een hexadecimale string [3](#page=3). Bij het gebruik van gehele getallen is het belangrijk om te letten op de notatie (bv. `0x` prefix) en het aantal hexadecimale symbolen, wat kan leiden tot impliciete nullen aan het begin indien het aantal oneven is [3](#page=3). > **Tip:** Gebruik bij voorkeur byte-strings voor de permutatie operatie in Python om ambiguïteit te vermijden, vooral bij oneven aantallen hexadecimale tekens. Zorg ervoor dat de permutatie functie correct is aangepast om zowel integers als byte-strings te ondersteunen [3](#page=3). --- # Variaties op blokcijferberekeningen Dit onderwerp behandelt diverse methoden en scenario's voor de toepassing van blokcijfers, waaronder het verwerken van meerdere blokken, specifieke modi zoals Electronic Codebook (ECB), Cipher Block Chaining (CBC) en Counter (CTR), evenals het proces van decryptie met behulp van de inverse S-box [4](#page=4). ### 3.1 Toepassing op meerdere blokken Bij het werken met berichten die langer zijn dan de blokgrootte van het cijfer, worden deze opgedeeld in meerdere blokken. Het is essentieel om te herkennen wanneer een bericht uit meerdere blokken bestaat, zelfs als dit niet expliciet wordt vermeld; de blokgrootte kan hierbij helpen [4](#page=4). ### 3.2 Verschillende cifieermodi Verschillende modi bepalen hoe de blokcijfers worden toegepast op opeenvolgende blokken van de plaintext. #### 3.2.1 Electronic Codebook (ECB) mode In de ECB-modus wordt elk blok plaintext onafhankelijk van de andere blokken versleuteld met dezelfde sleutel. Dit betekent dat identieke plaintextblokken resulteren in identieke ciphertextblokken [4](#page=4). #### 3.2.2 Cipher Block Chaining (CBC) mode CBC-modus introduceert een afhankelijkheid tussen opeenvolgende blokken. Elk plaintextblok wordt eerst XOR-verenigd met het voorgaande ciphertextblok voordat het wordt versleuteld. Voor het eerste blok wordt een Initialisatievector (IV) gebruikt. Als de IV niet gespecificeerd is, wordt deze vaak als nul aangenomen. De formule voor encryptie in CBC is [4](#page=4): $$ C_i = E_K(P_i \oplus C_{i-1}) $$ waarbij $C_i$ het $i$-de ciphertextblok is, $P_i$ het $i$-de plaintextblok, $E_K$ de encryptiefunctie met sleutel $K$, en $C_0$ de IV is [4](#page=4). #### 3.2.3 Counter (CTR) mode De CTR-modus gebruikt een teller die voor elk blok wordt verhoogd. De teller wordt versleuteld met de sleutel, en het resultaat wordt vervolgens XOR-verenigd met het plaintextblok om de ciphertext te verkrijgen. De formules zijn [4](#page=4): $$ C_i = P_i \oplus E_K(\text{counter}_i) $$ $$ \text{counter}_i = \text{IV} + i $$ waarbij $\text{counter}_i$ de waarde van de teller voor het $i$-de blok is, en IV de initialisatievector [4](#page=4). > **Tip:** De CTR-modus kan parallel worden uitgevoerd omdat de encryptie van elk blok afhankelijk is van de tellerwaarde en niet van voorgaande ciphertextblokken, wat efficiëntie kan bieden. ### 3.3 Decryptie met inverse S-box Voor het decryptieproces, met name in de context van substitutiecijfers, is de inverse S-box cruciaal. Als de S-box en de inverse S-box worden verstrekt, kan de inverse S-box gebruikt worden om de oorspronkelijke plaintext uit de ciphertext te reconstrueren [4](#page=4). > **Voorbeeld:** Als de encryptie van een karakter 'A' met een S-box resulteert in 'X', dan zal het toepassen van de inverse S-box op 'X' weer 'A' opleveren. Dit principe geldt ook voor complexere blokcijferstructuren die S-boxes gebruiken als onderdeel van hun algoritme [4](#page=4). --- ## Veelgemaakte fouten om te vermijden - Bestudeer alle onderwerpen grondig voor examens - Let op formules en belangrijke definities - Oefen met de voorbeelden in elke sectie - Memoriseer niet zonder de onderliggende concepten te begrijpen

| Term | Definition | |------|------------| | Blokcijfer | Een symmetrisch encryptie-algoritme dat gegevens verwerkt in vaste blokken van een bepaalde grootte, waarbij elke blok onafhankelijk of in relatie tot voorgaande blokken wordt verwerkt. | | Permutatie | Een herschikking of herordening van de elementen in een reeks. In de context van cryptografie wordt dit vaak toegepast op de bits of bytes van een blok om de gegevens te verspreiden. | | S-box (Substitutie Box) | Een cryptografisch primitief dat gebruikt wordt in veel blokcijfers, zoals de AES. Het vervangt een invoerreeks van bits door een uitvoerreeks van bits, met als doel niet-lineariteit te introduceren. | | XOR | Een binaire logische operatie die een 1 produceert als de twee ingangsbitten verschillend zijn, en een 0 als ze gelijk zijn. Het wordt vaak gebruikt in cryptografie om de platte tekst te versleutelen met de sleutel. | | Sleutel | Een stuk informatie, meestal een reeks bits, dat wordt gebruikt om een cryptografisch algoritme te besturen. De veiligheid van de encryptie hangt sterk af van de geheimhouding van de sleutel. | | Byte | Een eenheid van digitale informatie die bestaat uit acht bits. Een byte kan $2^8 = 256$ verschillende waarden vertegenwoordigen. | | Bits | De kleinste eenheid van data in een computer, die de waarde 0 of 1 kan hebben. | | ECB (Electronic Codebook) | Een werkingsmodus voor blokcijfers waarbij elk blok platte tekst onafhankelijk wordt versleuteld met dezelfde sleutel. Dit kan leiden tot patronen in de versleutelde tekst als de platte tekst repetitieve secties bevat. | | CBC (Cipher Block Chaining) | Een werkingsmodus voor blokcijfers waarbij elk blok platte tekst wordt XOR-ed met het voorgaande versleutelde blok voordat het wordt versleuteld. Dit introduceert afhankelijkheid tussen de blokken en zorgt voor een uniekere versleutelde tekst. | | CTR (Counter) | Een werkingsmodus voor blokcijfers die een teller gebruikt om unieke sleutelstromen te genereren voor elk blok. Het combineert cryptografische functies zoals encryptie met een teller, die wordt verhoogd voor elk blok. | | IV (Initialisatievector) | Een niet-geheime waarde die wordt gebruikt om een willekeurigheidselement toe te voegen aan het versleutelingsproces, met name in modi zoals CBC en CTR. Het zorgt ervoor dat identieke platte tekstblokken, bij gebruik met dezelfde sleutel, tot verschillende versleutelde tekstblokken leiden. | | Decryptie | Het proces van het omzetten van versleutelde gegevens (cipher text) terug naar de oorspronkelijke, begrijpelijke vorm (plain text), meestal met behulp van een decryptiesleutel. |