Base64 सुरक्षा सर्वोत्तम प्रथाएं

// BASE64 एन्क्रिप्शन नहीं है

सबसे महत्वपूर्ण सुरक्षा भ्रम Base64 को encryption की तरह treat करना है। Base64 केवल encoding है - यह बिना किसी key या password के पूरी तरह से reversible है।

कोई भी व्यक्ति Base64 data को तुरंत decode कर सकता है। Security या data protection के लिए कभी भी Base64 पर भरोसा न करें।

// ❌ गलत: Base64 को 'security' के रूप में उपयोग करना
const password = 'secret123';
const encoded = btoa(password); // cGFzc3dvcmQ=
// कोई भी इसे तुरंत decode कर सकता है!

// ✅ सही: उचित password hashing
import bcrypt from 'bcrypt';
const password = 'secret123';
const hashedPassword = await bcrypt.hash(password, 12);
// यह वास्तव में secure है

// इनपुट सत्यापन

Injection attacks और application errors को रोकने के लिए हमेशा Base64 input को validate करें:

उचित validation malicious input को security issues या application crashes पैदा करने से रोकती है।

// Base64 format को validate करें
function isValidBase64(str) {
    // Format check: केवल valid Base64 characters
    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
    if (!base64Regex.test(str)) {
        return false;
    }
    
    // Length check (4 का गुणक होना चाहिए)
    if (str.length % 4 !== 0) {
        return false;
    }
    
    // Decoding test
    try {
        atob(str);
        return true;
    } catch (e) {
        return false;
    }
}

// Validation के साथ safe decoding
function safeBase64Decode(input, maxLength = 10000) {
    if (typeof input !== 'string') {
        throw new Error('Input string होना चाहिए');
    }
    
    if (input.length > maxLength) {
        throw new Error('Input बहुत लंबा है');
    }
    
    if (!isValidBase64(input)) {
        throw new Error('Invalid Base64');
    }
    
    return atob(input);
}

// XSS रोकथाम

Base64 data में decode होने पर malicious scripts हो सकते हैं। Decoded content display करते समय हमेशा output को sanitize करें:

Users से Base64 input पर कभी भी भरोसा न करें। HTML में render करने से पहले हमेशा sanitize करें।

// ❌ खतरनाक: Direct HTML injection
function displayDecodedData(base64) {
    const decoded = atob(base64);
    document.innerHTML = decoded; // XSS vulnerability!
}

// ✅ सुरक्षित: Output को sanitize करें
function safeDisplayDecodedData(base64) {
    const decoded = atob(base64);
    
    // Text node बनाएं (कोई HTML execution नहीं)
    const textNode = document.createTextNode(decoded);
    container.appendChild(textNode);
    
    // या HTML entities को escape करें
    const escaped = decoded
        .replace(/&/g, '&amp;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#x27;');
    
    container.innerHTML = escaped;
}

// साइज़ सीमाएं

Base64 encoding डेटा का साइज़ ~33% बढ़ाती है। DoS attacks को रोकने के लिए size limits implement करें:

Unrestricted Base64 input excessive memory और processing power consume कर सकता है।

> Maximum input length limits सेट करें
> Processing के दौरान memory usage monitor करें
> Long operations के लिए timeouts implement करें
> बड़े data sets के लिए streaming का उपयोग करें
> Encoding से पहले compression पर विचार करें
> Base64 operations को rate limit करें

// सुरक्षित टोकन हैंडलिंग

Tokens या sensitive IDs के लिए Base64 का उपयोग करते समय, security best practices का पालन करें:

उचित token handling unauthorized access और token-based attacks को रोकती है।

// Secure token creation
function createSecureToken() {
    // Cryptographically secure random values का उपयोग करें
    const array = new Uint8Array(32);
    crypto.getRandomValues(array);
    
    // Base64 में convert करें और URL-safe बनाएं
    const base64 = btoa(String.fromCharCode(...array))
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
    
    return base64;
}

// Secure token validation
function validateToken(token, expectedLength = 43) {
    if (typeof token !== 'string') {
        return false;
    }
    
    // Length check करें
    if (token.length !== expectedLength) {
        return false;
    }
    
    // URL-safe Base64 format check करें
    const urlSafeBase64Regex = /^[A-Za-z0-9_-]+$/;
    return urlSafeBase64Regex.test(token);
}

// DATA URI सुरक्षा

Base64 data URIs में malicious content हो सकती है। हमेशा data URIs को validate और sanitize करें:

Malicious data URIs scripts execute कर सकते हैं, external resources load कर सकते हैं, या inappropriate content contain कर सकते हैं।

// Data URI को validate करें
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('Invalid data URI format');
    }
    
    const [, mimeType, base64Data] = match;
    
    // MIME type को validate करें
    if (!allowedTypes.includes(mimeType)) {
        throw new Error(`Unsupported MIME type: ${mimeType}`);
    }
    
    // Base64 data को validate करें
    if (!isValidBase64(base64Data)) {
        throw new Error('Invalid Base64 in data URI');
    }
    
    // Size check करें
    const sizeEstimate = (base64Data.length * 3) / 4;
    if (sizeEstimate > 1024 * 1024) { // 1MB limit
        throw new Error('Data URI बहुत बड़ा है');
    }
    
    return { mimeType, base64Data };
}

// सुरक्षित कार्यान्वयन चेकलिस्ट

> कभी भी Base64 को encryption या security measure के रूप में उपयोग न करें
> हमेशा Base64 input format और length को validate करें
> Display करने से पहले decoded output को sanitize करें
> Size limits और timeouts implement करें
> Web applications के लिए URL-safe Base64 का उपयोग करें
> Data URIs के लिए MIME types को validate करें
> Tokens के लिए cryptographically secure random values का उपयोग करें
> उचित error handling implement करें
> Potential DoS attacks के लिए monitor करें
> Base64 handling code के नियमित security audits करें

[Base64.sh]