Van magazinethema naar projectpraktijk
Relevante dienst- en technische pagina's bij het artikel
U krijgt een support-mail: „Exportbestand laat zich na update niet meer importeren.“ De bestandsnaam klopt, het wachtwoord „is zeker goed“, en bij de ene klant werkt het, bij de andere niet. Als men dan in de implementatie kijkt, staat daar vaak in feite: Wachtwoord → SHA256 → AES-CBC met vaste IV → Base64. Juist op dat punt wordt AES Verschlüsselung Delphi van een „algoritmeprobleem“ tot een exploitatieprobleem: geen versiebeheer, hergebruikte IVs, geen integriteit en geen zuivere parameters in het dataformaat.
Deze refresh levert daarom geen „AES-string versleutelen“-snippet, maar een klein, betrouwbaar containerformaat voor streams (bestanden, BLOBs, backups). Met Magic/Version, PBKDF2-Key-Derivation (KDF = Key Derivation Function, dus wachtwoord-naar-key-afleiding), willekeurige salt en IV – plus een optioneel integriteitspad (HMAC), dat de typische „padding kapot“-foutbeelden in de praktijk verzacht.
Scenarioanalyse: Waar AES in Delphi-projecten echt faalt
Gekunstelde, maar zeer typische situatie in individuele bedrijfssoftware: Een Delphi-client exporteert overdag versleutelde documenten; een serverdienst (Windows- of Windows- en Linux-services) importeert ’s nachts. Na een rollout worden sommige bestanden „onleesbaar“. De oorzaken zijn zelden „AES is kapot“, maar:
- IV-hergebruik: CBC (Cipher Block Chaining) vereist per versleuteling een nieuwe IV (initialisatievector). Een vaste IV is een reëel informatielek, zeker bij gelijksoortige bestandskoppen.
- Geen formaatcontract: Zonder Magic/Version/Parameter is niet te herleiden waarmee is versleuteld (aantal iteraties, modus, salt-lengte, padding).
- Geen integriteit: AES-CBC beschermt vertrouwelijkheid, maar niet tegen manipulatie. In de praktijk betekent dat: een enkele bitflip (opslag/transport) kan leiden tot moeilijk te diagnosticeren exceptions.
- „Wachtwoord is key“: Direct hashen of afkappen van een wachtwoord als AES-key maakt offline-aanvallen onnodig gemakkelijk.
AES Verschlüsselung Delphi als container: Header, Salt, IV, Parameter
De kerntruc is onspectaculair maar cruciaal: we versleutelen niet „een willekeurige string“, maar definiëren een minimaal containerformaat dat te versioneren en te debuggen is. Voorstel voor versie 1:
| Veld | Grootte | Doel |
|---|---|---|
| Magic | 4 Byte | Snelle formatcontrole (bijv. „NBAE“) |
| Version | 1 Byte | Migratiepad: „read old, write new“ |
| Iterations | 4 Byte | PBKDF2-parameters, later verhoogbaar |
| Salt | 16 Byte | Uniek per container, voor KDF |
| IV | 16 Byte | Uniek per container, voor AES-CBC |
| Ciphertekst | variabel | Streamversleutelde nuttige gegevens |
| HMAC (optioneel) | 32 Byte | Integriteit über Header+Ciphertekst |
Belangrijk: Salt en IV zijn niet geheim. Ze mogen in de Header staan. Geheim blijft het wachtwoord respectievelijk de daaruit afgeleide sleutel.
Delphi-Bron: Stream-container met PBKDF2, AES-CBC en optionele HMAC
De code is opzettelijk zo geschreven dat u eronder uw Crypto-Library (bijv. DEC of een interne CNG/OpenSSL-Anbindung) kunt uitwisselen. Het waardevolle is het formaat, het streamingpatroon en de discipline in foutafhandeling.
unit Nb.AesContainer;
interface
uses
System.SysUtils, System.Classes;
type
ENbCryptoError = class(Exception);
TNbAesContainer = class
public
class procedure EncryptStreamToStream(const AIn, AOut: TStream;
const APassword: string; const AIterations: Cardinal = 200000;
const AWithHmac: Boolean = True);
class procedure DecryptStreamToStream(const AIn, AOut: TStream;
const APassword: string; const AExpectHmac: Boolean = True);
end;
implementation
const
CMagic: array[0..3] of AnsiChar = ('N','B','A','E');
CVersionV1: Byte = 1;
CSaltLen = 16;
CIvLen = 16;
CHmacLen = 32; // HMAC-SHA-256
type
TNbHeaderV1 = packed record
Magic: array[0..3] of AnsiChar;
Version: Byte;
Flags: Byte; // Bit0: HMAC aanwezig
Iterations: Cardinal;
Salt: array[0..CSaltLen-1] of Byte;
IV: array[0..CIvLen-1] of Byte;
end;
// --- Bibliotheekafhankelijke primitieve (plaatsvervanger) ---
procedure FillRandomBytes(var B: TBytes);
begin
// MOET een OS-CSPRNG zijn, geen Random().
// Windows: BCryptGenRandom; Linux: getrandom()/urandom.
raise ENbCryptoError.Create('FillRandomBytes: CSPRNG niet gekoppeld');
end;
function PBKDF2_HMAC_SHA256(const APassword: string; const ASalt: TBytes;
const AIterations, AKeyLen: Cardinal): TBytes;
begin
// Levert AKeyLen bytes. Voor AES(32) + HMAC(32) bijv. 64.
raise ENbCryptoError.Create('PBKDF2_HMAC_SHA256: niet gekoppeld');
end;
procedure AES256_CBC_EncryptStream(const AKey, AIV: TBytes; const AIn, AOut: TStream);
begin
// Stream-implementatie met PKCS#7 padding.
raise ENbCryptoError.Create('AES256_CBC_EncryptStream: niet gekoppeld');
end;
procedure AES256_CBC_DecryptStream(const AKey, AIV: TBytes; const AIn, AOut: TStream);
begin
raise ENbCryptoError.Create('AES256_CBC_DecryptStream: niet gekoppeld');
end;
function HMAC_SHA256_Stream(const AKey: TBytes; const AIn: TStream;
const AFromPos, AToPosExclusive: Int64): TBytes;
begin
// HMAC over een streambereik; moet de positie daarna herstellen.
raise ENbCryptoError.Create('HMAC_SHA256_Stream: niet gekoppeld');
end;
// --- Header I/O ---
procedure WriteHeaderV1(const AOut: TStream; const H: TNbHeaderV1);
begin
if AOut.Write(H, SizeOf(H)) <> SizeOf(H) then
raise ENbCryptoError.Create('Header kon niet worden geschreven');
end;
function ReadHeaderV1(const AIn: TStream): TNbHeaderV1;
var
H: TNbHeaderV1;
I: Integer;
begin
if AIn.Read(H, SizeOf(H)) <> SizeOf(H) then
raise ENbCryptoError.Create('Header onvolledig');
for I := 0 to 3 do
if H.Magic[I] <> CMagic[I] then
raise ENbCryptoError.Create('Geen geldige container (Magic klopt niet)');
if H.Version <> CVersionV1 then
raise ENbCryptoError.CreateFmt('Onbekende containerversie: %d', [H.Version]);
// Plausibiliteitsgrenzen ter voorkoming van DoS door absurde KDF-parameters
if (H.Iterations < 10000) or (H.Iterations > 5000000) then
raise ENbCryptoError.Create('Aantal iteraties buiten plausibele grenzen');
Result := H;
end;
class procedure TNbAesContainer.EncryptStreamToStream(const AIn, AOut: TStream;
const APassword: string; const AIterations: Cardinal; const AWithHmac: Boolean);
var
H: TNbHeaderV1;
Salt, IV, KeyMaterial, AesKey, HmacKey: TBytes;
StartPos, EndPos: Int64;
Mac: TBytes;
Flags: Byte;
begin
if APassword = '' then
raise ENbCryptoError.Create('Wachtwoord mag niet leeg zijn');
SetLength(Salt, CSaltLen);
SetLength(IV, CIvLen);
FillRandomBytes(Salt);
FillRandomBytes(IV);
Flags := 0;
if AWithHmac then
Flags := Flags or $01;
Move(CMagic[0], H.Magic[0], 4);
H.Version := CVersionV1;
H.Flags := Flags;
H.Iterations := AIterations;
Move(Salt[0], H.Salt[0], CSaltLen);
Move(IV[0], H.IV[0], CIvLen);
WriteHeaderV1(AOut, H);
// Key separation: 64 bytes uit PBKDF2 afleiden en opsplitsen.
KeyMaterial := PBKDF2_HMAC_SHA256(APassword, Salt, AIterations, 64);
SetLength(AesKey, 32);
SetLength(HmacKey, 32);
Move(KeyMaterial[0], AesKey[0], 32);
Move(KeyMaterial[32], HmacKey[0], 32);
StartPos := AOut.Position; // Ciphertext begint hier
AES256_CBC_EncryptStream(AesKey, IV, AIn, AOut);
EndPos := AOut.Position;
// Optioneel: HMAC over header+ciphertext.
if AWithHmac then
begin
// HMAC-bereik: van 0 (Header) tot EndPos (exclusief), daarna Mac toevoegen.
Mac := HMAC_SHA256_Stream(HmacKey, AOut, 0, EndPos);
if Length(Mac) <> CHmacLen then
raise ENbCryptoError.Create('Onverwachte HMAC-lengte');
if AOut.Write(Mac[0], Length(Mac)) <> Length(Mac) then
raise ENbCryptoError.Create('HMAC kon niet worden geschreven');
end;
end;
class procedure TNbAesContainer.DecryptStreamToStream(const AIn, AOut: TStream;
const APassword: string; const AExpectHmac: Boolean);
var
H: TNbHeaderV1;
Salt, IV, KeyMaterial, AesKey, HmacKey: TBytes;
HasHmac: Boolean;
DataEndPos, MacPos: Int64;
StoredMac, CalcMac: TBytes;
begin
if APassword = '' then
raise ENbCryptoError.Create('Wachtwoord mag niet leeg zijn');
H := ReadHeaderV1(AIn);
HasHmac := (H.Flags and $01) = $01;
if AExpectHmac and (not HasHmac) then
raise ENbCryptoError.Create('Container heeft geen HMAC, integriteit niet verifieerbaar');
SetLength(Salt, CSaltLen);
SetLength(IV, CIvLen);
Move(H.Salt[0], Salt[0], CSaltLen);
Move(H.IV[0], IV[0], CIvLen);
KeyMaterial := PBKDF2_HMAC_SHA256(APassword, Salt, H.Iterations, 64);
SetLength(AesKey, 32);
SetLength(HmacKey, 32);
Move(KeyMaterial[0], AesKey[0], 32);
Move(KeyMaterial[32], HmacKey[0], 32);
// Als HMAC aanwezig is: eerst controleren vóór decryptie.
if HasHmac then
begin
DataEndPos := AIn.Size - CHmacLen;
if DataEndPos < SizeOf(TNbHeaderV1) then
raise ENbCryptoError.Create('Container te klein');
MacPos := DataEndPos;
SetLength(StoredMac, CHmacLen);
AIn.Position := MacPos;
if AIn.Read(StoredMac[0], CHmacLen) <> CHmacLen then
raise ENbCryptoError.Create('HMAC kon niet worden gelezen');
CalcMac := HMAC_SHA256_Stream(HmacKey, AIn, 0, MacPos);
if Length(CalcMac) <> CHmacLen then
raise ENbCryptoError.Create('Onverwachte HMAC-lengte');
if not CompareMem(@StoredMac[0], @CalcMac[0], CHmacLen) then
raise ENbCryptoError.Create('HMAC ongeldig (wachtwoord onjuist of gegevens beschadigd)');
// Ciphertext bevindt zich tussen het einde van de Header en MacPos
AIn.Position := SizeOf(TNbHeaderV1);
// De werkelijke stream-decrypt-implementatie moet tot MacPos lezen.
// Variant: AIn in een beperkte stream (RangeStream) wrappen.
end
else
AIn.Position := SizeOf(TNbHeaderV1);
// Opmerking: Voor HasHmac=True zou AES256_CBC_DecryptStream niet tot EOF moeten lezen,
// maar tot vóór de HMAC. Los dit netjes op met een RangeStream-wrapper.
AES256_CBC_DecryptStream(AesKey, IV, AIn, AOut);
end;
end.
Doel: Een container die tijdens de exploitatie uitlegbaar blijft: Magic/versie voor diagnose, iteratieaantal voor latere aanpassingen, Salt/IV per bestand, streamverwerking in plaats van RAM-pieken. Randvoorwaarden: U moet (1) een echte CSPRNG aansluiten en (2) uw Crypto-Library streamable inzetten. Valkuilen: Het decrypt-pad met HMAC heeft een begrenzing („RangeStream“) nodig, zodat de AES-decrypt niet per ongeluk de aangehechte HMAC als ciphertext interpreteert. Varianten: In plaats van CBC+HMAC kunt u overstappen op AES-GCM (AEAD = Authenticated Encryption with Associated Data, dus versleuteling plus authenticatie in één stap), als uw bibliotheek dat stabiel kan.
Waarom KDF en willekeur geen details zijn (met bronnen)
Twee beweringen die in Reviews steeds weer worden besproken, zijn duidelijk te onderbouwen:
- Salt en IV moeten uit cryptografisch veilige willekeur komen: Een CSPRNG (Cryptographically Secure PRNG) is zo ontworpen dat uit waargenomen uitgangen geen voorspellingen mogelijk zijn. Juist daarom is
Random()of „Hash aus Zeitstempel“ ongeschikt. Voor Windows is dit in de platform-API via CNG af te beelden; instappunt is bijv. Microsofts CNG-Portal. - PBKDF2 is geen luxe, maar een remblok tegen offline-aanvallen: Wachtwoorden zijn typisch zwakker dan keys; PBKDF2 verhoogt doelgericht de kosten per wachtwoordpoging. De werking is netjes beschreven in RFC 8018 (PKCS #5), inclusief parameters en veiligheidsafwegingen.
Migratiepad: „read old, write new“ zonder onderhoudsvenster
Als er al data in het veld ligt, is een Big-Bang-migratie zelden realistisch. Een praktijkgeschikt pad:
- Detectie: Magic+Version controleren. Als geen Magic, optioneel fallback naar legacy-heuristiek (bijv. Base64-patroon, oude header-lengte).
- Lezen: Oude formaten blijven kunnen ontsleutelen (alleen in een duidelijk geïsoleerde module, zodat het later verwijderbaar blijft).
- Schrijven: Vanaf een peildatum uitsluitend het nieuwe formaat genereren (versie 1 met Salt/IV/KDF, optioneel HMAC).
- Lazy-migratie: Bij succesvol lezen van een legacy-container op de achtergrond naar het nieuwe formaat re-encrypten, als proces en performance dat toelaten.
Threading, streams en foutbeelden: exploitatie in plaats van demo
In desktop-clients en services staat AES zelden alleen: export-threads, achtergrond-tasks, BDE-vervanging met native koppeling-BLOB-streams, upload naar REST-API’s. Drie punten vermijden onnodige incidenten:
- Stream-contract documenteren: Lezen/schrijven vanaf de huidige positie. Voor hergebruik positie expliciet instellen. Dat klinkt banaal, maar is een veelvoorkomende oorzaak van „sporadisch kaputt“.
- Fouten extern neutraal, intern precies: Extern „Ongeldige container of onjuist wachtwoord“. Intern onderscheiden: Magic/Version-fout, iteratiegrenzen, HMAC/tag ongeldig, Decrypt-/Padding-exceptie.
- Integriteit eerst controleren: Bij CBC+HMAC eerst de HMAC controleren, daarna ontsleutelen. Dat vermindert side-channel-achtige foutpatronen en bespaart CPU bij corrupte gegevens.
Grenzen en risico’s: Wat deze aanpak niet oplost
Een containerformaat is geen vervanging voor transportversleuteling of sleutelbeheer:
- TLS blijft verplicht voor gegevensoverdracht. AES in de payload vervangt geen degelijk HTTPS/TLS-setup.
- Wachtwoordbeheer is een eigen onderwerp: Als u „wachtwoord in code“ of „in INI“ opslaat, wint u met AES maar beperkt. Voor secrets zijn OS-secret-stores of Vault-concepten vaak geschikter.
- Interop vereist specificatie: Als andere talen het verwerken, moeten endianness, padding/mode, headerlayout en encoding exact worden gedocumenteerd (of u gebruikt een gevestigd uitwisselingsformaat).
Conclusie: AES-versleuteling Delphi is een format- en bedrijfscontract
Het verschil tussen „AES werkt“ en „AES blijft goed functioneren in het veld“ is niet het algoritme, maar de engineeringomgeving: container-headers met versie, salt/IV per object, PBKDF2 met geparametriseerd iteratieaantal, streamverwerking en (voor nieuwe data) integriteit via HMAC of GCM. Juist deze discipline maakt versleuteling in volwassen Delphi-landschappen onderhoudbaar, migreerbaar en debugbaar.
Als u een legacy-formaat moet vervangen of de crypto-laag in een Delphi-client/service netjes wilt kapselen (inclusief RangeStream, Logging en migratiepad), laat zich dat het snelst in een kort architectuur-review oplossen: neem contact op.
Voor dit onderwerp zijn ook Aes-256-Cbc Delphi en Delphi Aes belangrijk. Het artikel ordent deze aspecten begrijpelijk en laat zien waar het in de dagelijkse praktijk om gaat.
volgende stap
Wanneer het onderwerp een concreet project wordt, moeten architectuur, bestaande omgeving en exploitatie vroegtijdig samen worden bekeken.
We ondersteunen niet alleen bij individuele vragen, maar ook wanneer uit broncodefragmenten, legacy-onderwerpen of portalideeën een robuust bedrijfsproject moet ontstaan.
- Huidige situatie, doelbeeld en technische risico's worden gezamenlijk beoordeeld.
- REST, toegang tot gegevens, portalen en rollout worden niet naar latere fasen verschoven.
- U ziet vroeg welke weg economisch en operationeel levensvatbaar is.