[BEVEILIGING] Base64 Beveiliging Best Practices
Belangrijke beveiligingsoverwegingen bij het werken met Base64 codering in webapplicaties.
// BASE64 IS GEEN VERSLEUTELING
De meest kritieke beveiligingsmisvatting is Base64 behandelen als versleuteling. Base64 is alleen maar codering - het is volledig omkeerbaar zonder enige sleutel of wachtwoord.
Iedereen kan Base64-data onmiddellijk decoderen. Vertrouw nooit op Base64 voor beveiliging of gegevensbescherming.
// ❌ FOUT: Base64 gebruiken als 'beveiliging'
const password = 'secret123';
const encoded = btoa(password); // cGFzc3dvcmQ=
// Iedereen kan dit onmiddellijk decoderen!
// ✅ JUIST: Juiste wachtwoord hashing
import bcrypt from 'bcrypt';
const password = 'secret123';
const hashedPassword = await bcrypt.hash(password, 12);
// Dit is echt veilig
// INVOERVALIDATIE
Valideer altijd Base64-invoer om injectie-aanvallen en applicatiefouten te voorkomen:
Juiste validatie voorkomt dat kwaadaardige invoer beveiligingsproblemen of applicatiecrashes veroorzaakt.
// Valideer Base64-formaat
function isValidBase64(str) {
// Controleer formaat: alleen geldige Base64-karakters
const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
if (!base64Regex.test(str)) {
return false;
}
// Controleer lengte (moet een veelvoud van 4 zijn)
if (str.length % 4 !== 0) {
return false;
}
// Test decodering
try {
atob(str);
return true;
} catch (e) {
return false;
}
}
// Veilige decodering met validatie
function safeBase64Decode(input, maxLength = 10000) {
if (typeof input !== 'string') {
throw new Error('Invoer moet string zijn');
}
if (input.length > maxLength) {
throw new Error('Invoer te lang');
}
if (!isValidBase64(input)) {
throw new Error('Ongeldige Base64');
}
return atob(input);
}
// XSS PREVENTIE
Base64-data kan kwaadaardige scripts bevatten wanneer gedecodeerd. Zuiver altijd uitvoer bij het weergeven van gedecodeerde inhoud:
Vertrouw nooit Base64-invoer van gebruikers. Zuiver altijd voordat je rendert in HTML.
// ❌ GEVAARLIJK: Directe HTML-injectie
function displayDecodedData(base64) {
const decoded = atob(base64);
document.innerHTML = decoded; // XSS-kwetsbaarheid!
}
// ✅ VEILIG: Uitvoer zuiveren
function safeDisplayDecodedData(base64) {
const decoded = atob(base64);
// Tekstnode maken (geen HTML-uitvoering)
const textNode = document.createTextNode(decoded);
container.appendChild(textNode);
// Of HTML-entiteiten escapen
const escaped = decoded
.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
container.innerHTML = escaped;
}
// GROOTTELIMIETEN
Base64-codering vergroot datagrootte met ~33%. Implementeer groottelimieten om DoS-aanvallen te voorkomen:
Onbeperkte Base64-invoer kan overmatig geheugen en verwerkingskracht verbruiken.
- > Stel maximale invoerlengtelimieten in
- > Monitor geheugengebruik tijdens verwerking
- > Implementeer timeouts voor lange bewerkingen
- > Gebruik streaming voor grote datasets
- > Overweeg compressie voor codering
- > Beperk snelheid van Base64-bewerkingen
// VEILIGE TOKEN BEHANDELING
Bij het gebruiken van Base64 voor tokens of gevoelige ID's, volg beveiligings best practices:
Juiste tokenbehandeling voorkomt ongeautoriseerde toegang en token-gebaseerde aanvallen.
// Veilige token creatie
function createSecureToken() {
// Gebruik cryptografisch veilige willekeurige waarden
const array = new Uint8Array(32);
crypto.getRandomValues(array);
// Converteer naar Base64 en maak URL-veilig
const base64 = btoa(String.fromCharCode(...array))
.replace(/\+/g, '-')
.replace(/\//g, '_')
.replace(/=/g, '');
return base64;
}
// Veilige token validatie
function validateToken(token, expectedLength = 43) {
if (typeof token !== 'string') {
return false;
}
// Controleer lengte
if (token.length !== expectedLength) {
return false;
}
// Controleer URL-veilige Base64-formaat
const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
return urlSafeBase64Regex.test(token);
}
// DATA URI BEVEILIGING
Base64 data URI's kunnen kwaadaardige inhoud bevatten. Valideer en zuiver altijd data URI's:
Kwaadaardige data URI's kunnen scripts uitvoeren, externe bronnen laden of ongepaste inhoud bevatten.
// Valideer data URI
function validateDataURI(dataUri, allowedTypes = ['image/png', 'image/jpeg']) {
const dataUriRegex = /^data:([a-zA-Z0-9][a-zA-Z0-9\/+]*);base64,(.+)$/;
const match = dataUri.match(dataUriRegex);
if (!match) {
throw new Error('Ongeldig data URI-formaat');
}
const [, mimeType, base64Data] = match;
// Valideer MIME-type
if (!allowedTypes.includes(mimeType)) {
throw new Error(`Niet-ondersteund MIME-type: ${mimeType}`);
}
// Valideer Base64-data
if (!isValidBase64(base64Data)) {
throw new Error('Ongeldige Base64 in data URI');
}
// Controleer grootte
const sizeEstimate = (base64Data.length * 3) / 4;
if (sizeEstimate > 1024 * 1024) { // 1MB-limiet
throw new Error('Data URI te groot');
}
return { mimeType, base64Data };
}
// VEILIGE IMPLEMENTATIE CHECKLIST
- > Gebruik nooit Base64 als versleuteling of beveiligingsmaatregel
- > Valideer altijd Base64-invoerformaat en lengte
- > Zuiver gedecodeerde uitvoer voordat je weergeeft
- > Implementeer groottelimieten en timeouts
- > Gebruik URL-veilige Base64 voor webapplicaties
- > Valideer MIME-types voor data URI's
- > Gebruik cryptografisch veilige willekeurige waarden voor tokens
- > Implementeer juiste foutafhandeling
- > Monitor voor potentiële DoS-aanvallen
- > Regelmatige beveiligingsaudits van Base64-behandelingscode