[SIKKERHET] Base64 Sikkerhet Beste Praksis
Viktige sikkerhetshensyn når du arbeider med Base64-koding i webapplikasjoner.
// BASE64 ER IKKE KRYPTERING
Den mest kritiske sikkerhetsmisforståelsen er å behandle Base64 som kryptering. Base64 er bare koding - det er fullstendig reversibelt uten nøkkel eller passord.
Hvem som helst kan øyeblikkelig dekode Base64-data. Stol aldri på Base64 for sikkerhet eller databeskyttelse.
// ❌ FEIL: Bruke Base64 som 'sikkerhet'
const password = 'secret123';
const encoded = btoa(password); // cGFzc3dvcmQ=
// Hvem som helst kan dekode dette øyeblikkelig!
// ✅ RIKTIG: Riktig passord-hashing
import bcrypt from 'bcrypt';
const password = 'secret123';
const hashedPassword = await bcrypt.hash(password, 12);
// Dette er faktisk sikkert
// INPUT VALIDERING
Valider alltid Base64-input for å forhindre injeksjonsangrep og applikasjonsfeil:
Riktig validering forhindrer ondsinnet input fra å forårsake sikkerhetsproblemer eller applikasjonskrasj.
// Valider Base64-format
function isValidBase64(str) {
// Formatsjekk: kun gyldige Base64-tegn
const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
if (!base64Regex.test(str)) {
return false;
}
// Lengdesjekk (må være multiplum av 4)
if (str.length % 4 !== 0) {
return false;
}
// Test dekoding
try {
atob(str);
return true;
} catch (e) {
return false;
}
}
// Sikker dekoding med validering
function safeBase64Decode(input, maxLength = 10000) {
if (typeof input !== 'string') {
throw new Error('Input må være streng');
}
if (input.length > maxLength) {
throw new Error('Input for lang');
}
if (!isValidBase64(input)) {
throw new Error('Ugyldig Base64');
}
return atob(input);
}
// XSS FOREBYGGING
Base64-data kan inneholde ondsinnet skript når dekoded. Rens alltid output når dekoded innhold vises:
Stol aldri på Base64-input fra brukere. Rens alltid før rendering i HTML.
// ❌ FARLIG: Direkte HTML-injeksjon
function displayDecodedData(base64) {
const decoded = atob(base64);
document.innerHTML = decoded; // XSS-sårbarhet!
}
// ✅ SIKKERT: Rens output
function safeDisplayDecodedData(base64) {
const decoded = atob(base64);
// Opprett tekstnode (ingen HTML-utførelse)
const textNode = document.createTextNode(decoded);
container.appendChild(textNode);
// Eller escape HTML-entiteter
const escaped = decoded
.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
container.innerHTML = escaped;
}
// STØRRELSESGRENSER
Base64-koding øker datastørrelsen med ~33%. Implementer størrelsesgrenser for å forhindre DoS-angrep:
Ubegrenset Base64-input kan konsumere overdreven minne og prosessorkraft.
- > Sett maksimale inputlengdegrenser
- > Overvåk minnebruk under behandling
- > Implementer timeouts for lange operasjoner
- > Bruk streaming for store datasett
- > Vurder komprimering før koding
- > Ratebegrens Base64-operasjoner
// SIKKER TOKEN-HÅNDTERING
Når du bruker Base64 for tokens eller sensitive ID-er, følg sikkerhetens beste praksis:
Riktig token-håndtering forhindrer uautorisert tilgang og token-baserte angrep.
// Sikker token-opprettelse
function createSecureToken() {
// Bruk kryptografisk sikre tilfeldige verdier
const array = new Uint8Array(32);
crypto.getRandomValues(array);
// Konverter til Base64 og gjør URL-sikker
const base64 = btoa(String.fromCharCode(...array))
.replace(/\+/g, '-')
.replace(/\//g, '_')
.replace(/=/g, '');
return base64;
}
// Sikker token-validering
function validateToken(token, expectedLength = 43) {
if (typeof token !== 'string') {
return false;
}
// Sjekk lengde
if (token.length !== expectedLength) {
return false;
}
// Sjekk URL-sikkert Base64-format
const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
return urlSafeBase64Regex.test(token);
}
// DATA URI SIKKERHET
Base64 data URI-er kan inneholde ondsinnede innhold. Valider og rens alltid data URI-er:
Ondsinnet data URI-er kan utføre skript, laste eksterne ressurser eller inneholde upassende innhold.
// Valider 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('Ugyldig data URI-format');
}
const [, mimeType, base64Data] = match;
// Valider MIME-type
if (!allowedTypes.includes(mimeType)) {
throw new Error(`Ikke-støttet MIME-type: ${mimeType}`);
}
// Valider Base64-data
if (!isValidBase64(base64Data)) {
throw new Error('Ugyldig Base64 i data URI');
}
// Sjekk størrelse
const sizeEstimate = (base64Data.length * 3) / 4;
if (sizeEstimate > 1024 * 1024) { // 1MB grense
throw new Error('Data URI for stor');
}
return { mimeType, base64Data };
}
// SIKKER IMPLEMENTERING SJEKKLISTE
- > Bruk aldri Base64 som kryptering eller sikkerhetsgrep
- > Valider alltid Base64 input-format og lengde
- > Rens dekoded output før visning
- > Implementer størrelsesgrenser og timeouts
- > Bruk URL-sikker Base64 for webapplikasjoner
- > Valider MIME-typer for data URI-er
- > Bruk kryptografisk sikre tilfeldige verdier for tokens
- > Implementer riktig feilhåndtering
- > Overvåk for potensielle DoS-angrep
- > Regelmessige sikkerhetsgjennomganger av Base64-håndteringskode