𝗖𝗕𝗖 𝗕𝗶𝘁 𝗙𝗹𝗶𝗽𝗽𝗶𝗻𝗴 𝗘𝘅𝗽𝗹𝗮𝗶𝗻𝗲𝗱

Encryption does not mean your data is safe from tampering.

Many developers make this mistake. They think if an attacker cannot read the data, they cannot change it. This is wrong. Cryptography treats secrecy and integrity as two different tasks.

The CBC Bit Flipping attack proves this. An attacker can change your data without knowing your secret key.

Here is how it works:

AES does not encrypt data in one large piece. It breaks data into 16-byte blocks. In CBC mode, these blocks chain together. The encrypted output of the first block mixes into the plaintext of the second block.

This chain creates a weakness during decryption. To get the original text of Block 2, the server decrypts it and combines it with the ciphertext from Block 1.

An attacker can exploit this:

The attacker does not need to read the message. They just flip bits to change the final result.

Consider an old web app using encrypted cookies for sessions. A cookie might hold: userid=994;role=user;

An attacker intercepts this cookie and flips bits in the ciphertext. They send many requests until the server accepts one. Because the server only checks if the data decrypts, it processes the modified text. Suddenly, the decrypted string reads: userid=994;role=admi;

The attacker now has admin access. They never read the key or the original cookie.

The mistake is assuming encryption guarantees integrity.

To fix this, use Authenticated Encryption like AES-GCM. It creates a cryptographic tag. This tag acts like a seal. If an attacker changes even one bit, the seal breaks. The server rejects the data immediately.

If you must use CBC, use an Encrypt-then-MAC architecture. Create an authentication code for the ciphertext and verify it before you start decryption.

Secret data is not always trustworthy data. Always prove your data is unchanged before you use it to make decisions.

CBC Bit-Flipping uitgelegd: Waarom encryptie alleen geen integriteit garandeert

Encryptie wordt vaak direct geassocieerd met veiligheid. Maar er is een cruciaal onderscheid dat vaak over het hoofd wordt gezien: het verschil tussen vertrouwelijkheid (confidentiality) en integriteit (integrity).

In dit artikel leggen we uit hoe een aanvaller de inhoud van een versleuteld bericht kan wijzigen zonder de sleutel te kennen, met behulp van een techniek genaamd een CBC bit-flipping aanval.

Vertrouwelijkheid vs. Integriteit

Voordat we in de techniek duiken, moeten we deze twee concepten begrijpen:

  1. Vertrouwelijkheid: Zorgt ervoor dat alleen geautoriseerde personen de inhoud van een bericht kunnen lezen. Encryptie is hier uitstekend in.
  2. Integriteit: Zorgt ervoor dat het bericht niet is gewijzigd tijdens het transport. Encryptie alleen garandeert dit niet.

Stel je voor dat je een versleuteld bericht verstuurt: "Betaal €100 aan Alice". Een aanvaller kan de inhoud misschien niet lezen, maar als hij de bits in de ciphertext kan manipuleren, kan hij misschien de tekst veranderen in "Betaal €900 aan Alice", zonder ooit te weten wat de oorspronkelijke tekst was.

Wat is CBC-modus?

CBC (Cipher Block Chaining) is een modus voor blokcijfers (block ciphers). In plaats van elk blok onafhankelijk te versleutelen (zoals in ECB-modus), wordt elk blok van plaintext gekoppeld aan het vorige blok van ciphertext.

Het proces werkt als volgt:

  1. Het eerste blok van plaintext wordt ge-XOR'ed met een Initialization Vector (IV).
  2. Het resultaat wordt versleuteld.
  3. Voor elk volgend blok wordt de plaintext ge-XOR'ed met het vorige ciphertext-blok voordat het wordt versleuteld.

De wiskundige formule voor decryptie van blok $P_n$ is: $P_n = D_k(C_n) \oplus C_{n-1}$

Waar:

De Bit-Flipping Aanval

Kijk naar de decryptieformule: $P_n = D_k(C_n) \oplus C_{n-1}$.

Dit laat zien dat het gedecrypteerde plaintext-blok $P_n$ direct afhankelijk is van het vorige ciphertext-blok $C_{n-1}$ via een XOR-operatie.

Als een aanvaller een bit verandert in $C_{n-1}$, zal exact hetzelfde bit in $P_n$ veranderen na decryptie. De aanvaller weet misschien niet wat de exacte waarde van $P_n$ is, maar hij kan wel voorspellen hoe de verandering de tekst beïnvloedt.

Een voorbeeld

Stel dat we een ciphertext hebben die een JSON-object bevat: {"user": "guest", "admin": false}

De aanvaller wil de waarde van "admin" veranderen van false naar true.

  1. De aanvaller identificeert het ciphertext-blok dat verantwoordelijk is voor de tekst "false".
  2. De aanvaller weet dat de tekst in het volgende plaintext-blok zal verschijnen (of in hetzelfde blok, afhankelijk van de blokgrootte en uitlijning).
  3. Door specifieke bits in het vorige ciphertext-blok om te draaien (flippen), kan de aanvaller de tekst in het volgende blok manipuleren naar "true".

Let op: De manipulatie van $C_{n-1}$ zal het huidige blok $P_{n-1}$ volledig onleesbaar maken (corrupt maken), maar het volgende blok $P_n$ zal precies de gewenste wijziging bevatten. Als de applicatie alleen het tweede blok controleert, is de aanval succesvol.

Hoe kun je dit voorkomen?

De oplossing is simpel: gebruik encryptie die ook integriteit garandeert. Dit noemen we Authenticated Encryption (AE).

Er zijn twee hoofdmethoden om dit te doen:

1. Gebruik een MAC (Message Authentication Code)

Voeg een digitale handtekening of een HMAC (Hash-based Message Authentication Code) toe aan je ciphertext. Voordat je de data decrypt, controleer je of de HMAC nog klopt. Als er ook maar één bit is veranderd, zal de HMAC niet meer overeenkomen en moet de data als ongeldig worden beschouwd.

Workflow: Encrypt(Plaintext) -> Ciphertext + HMAC(Ciphertext)

2. Gebruik AEAD-modi (Authenticated Encryption with Associated Data)

Moderne cryptografische algoritmen zoals AES-GCM (Galois/Counter Mode) doen dit automatisch. Ze versleutelen de data en genereren tegelijkertijd een "authentication tag". Als er ook maar één bit in de ciphertext wordt gewijzigd, zal de decryptie mislukken.

Conclusie

Encryptie is essentieel voor vertrouwelijkheid, maar het is geen wondermiddel voor veiligheid. Zonder een mechanisme om de integriteit te controleren, is je systeem kwetsbaar voor manipulatie. Gebruik daarom altijd moderne, geauthenticeerde encryptiemethoden zoals AES-GCM om zowel vertrouwelijkheid als integriteit te waarborgen.