Base64 क्या है? एन्कोडिंग समझें

Base64 बाइनरी डेटा — इमेज, फ़ाइल, एन्क्रिप्टेड बाइट्स, कुछ भी — को सिर्फ़ 64 प्रिंट होने योग्य कैरेक्टर (A–Z, a–z, 0–9, + और /) से दिखाने का तरीका है। यह इसलिए है क्योंकि कई चैनल टेक्स्ट के लिए बने थे: ईमेल, JSON, XML, URL, HTTP हेडर और कुकी सभी Base64 स्ट्रिंग सुरक्षित रूप से ले जा सकते हैं जहाँ कच्चे बाइट्स बिगड़ जाते या रिजेक्ट हो जाते।

यह गाइड बताती है कि एन्कोडिंग कैसे काम करती है, यह कब सही विकल्प है, Base64 और Base64URL में क्या फ़र्क़ है, और वे गलतियाँ जो बिगड़ा आउटपुट देती हैं — सबसे अहम गलती समेत: Base64 एन्क्रिप्शन नहीं है।

Base64 एन्कोडिंग कैसे काम करती है

Base64 इनपुट को एक बार में तीन बाइट (24 बिट) लेता है और उन्हें छह-छह बिट के चार ग्रुप में बाँटता है। हर छह-बिट वैल्यू (0–63) अल्फ़ाबेट के एक कैरेक्टर से मैप होती है। तीन बाइट अंदर, चार कैरेक्टर बाहर — इसीलिए Base64 आउटपुट हमेशा इनपुट से लगभग 33% बड़ा होता है।

जब इनपुट की लंबाई तीन का गुणज नहीं होती, आख़िरी ग्रुप को ज़ीरो बिट से भरा जाता है और एक या दो "=" जोड़े जाते हैं ताकि डिकोडर जाने कि कितने असली बाइट की उम्मीद करनी है।

नीचे का उदाहरण क़दम-दर-क़दम: टेक्स्ट Hi! तीन बाइट है (Text और Bytes), उसके 24 बिट छह-छह बिट के चार ग्रुप में बँटते हैं (Groups), जिनकी वैल्यू 18, 6, 36 और 33 है (Index), यानी अल्फ़ाबेट में S, G, k और h — नतीजा SGkh। Hi सिर्फ़ दो बाइट है: आख़िरी ग्रुप दो ज़ीरो बिट से पूरा होता है और एक "=" जुड़ता है — नतीजा SGk=।

तीन बाइट यानी 24 बिट, जो दोबारा छह-छह बिट के चार ग्रुप में पढ़े जाते हैं: चार कैरेक्टर बाहर। अधूरा आख़िरी ग्रुप ज़ीरो बिट से भरा जाता है और "=" जुड़ता है।

Hi! — तीन बाइट, कोई पैडिंग नहीं

टेक्स्ट (Text)

H i !

बाइट (Bytes)

01001000 01101001 00100001

ग्रुप (Groups)

010010 000110 100100 100001

वैल्यू (Index)

18 6 36 33

नतीजा (Base64)

S G k h

Hi — दो बाइट, एक "=" पैडिंग

टेक्स्ट (Text)

H i

बाइट (Bytes)

01001000 01101001 00

ग्रुप (Groups)

010010 000110 100100

वैल्यू (Index)

18 6 36

नतीजा (Base64)

S G k =

ठोस रेखाएँ बाइट की सीमा हैं, डैश वाली रेखाएँ छह-बिट ग्रुप की। हल्के ख़ाने इनपुट के नहीं हैं: पैडिंग के ज़ीरो बिट और "=", और छूटे हुए बाइट की ख़ाली जगह।

पाठ संस्करण
Text:   Hi!
Bytes:  01001000 01101001 00100001
Groups: 010010 000110 100100 100001
Index:  18     6      36     33
Base64: S      G      k      h        → "SGkh"

Text:   Hi      (2 bytes → one "=" of padding)
Base64: SGk=

आज़माएँ: Base64 एन्कोडर आज़माएँ: बाइनरी एन्कोडर / डिकोडर

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

कोई भी Base64 को बिना key के तुरंत डिकोड कर सकता है — यह उलटने योग्य एन्कोडिंग है, जैसे किसी नंबर को हेक्साडेसिमल में लिखना। यह कुछ नहीं छिपाता। Base64 से "प्रोटेक्ट" किया पासवर्ड, API key या टोकन उसे देखने वाले हर व्यक्ति के सामने खुला है। डेटा प्रोटेक्ट करने के लिए असली एन्क्रिप्शन (AES, TLS) इस्तेमाल करें और Base64 सिर्फ़ उसे ले जाने के लिए।

आज़माएँ: Base64 डिकोडर

Base64 कब इस्तेमाल करें

  • छोटी इमेज या फ़ॉन्ट को HTML, CSS या JSON में data: URI के रूप में एम्बेड करना।
  • JSON या XML पेलोड के अंदर बाइनरी कंटेंट भेजना, जो सिर्फ़ टेक्स्ट रख सकते हैं।
  • HTTP Basic ऑथेंटिकेशन: हेडर में "username:password" का Base64 जाता है (सिर्फ़ ट्रांसपोर्ट — हमेशा HTTPS पर)।
  • JWT और दूसरे टोकन, जो अपने हेडर, पेलोड और सिग्नेचर के लिए URL-सेफ़ वेरिएंट इस्तेमाल करते हैं।
  • ईमेल अटैचमेंट (MIME) और कोई भी पुराना प्रोटोकॉल जो 7-बिट टेक्स्ट की उम्मीद करता है।
  • बड़ी फ़ाइलों के लिए नहीं, जहाँ बाइनरी चैनल मौजूद है — 33% ओवरहेड और अतिरिक्त एन्कोडिंग स्टेप सरासर बर्बादी है।

Base64 बनाम Base64URL

स्टैंडर्ड Base64 "+" और "/" इस्तेमाल करता है, दोनों का URL में ख़ास मतलब है, और "=" पैडिंग जो अक्सर परसेंट-एन्कोड होती है। Base64URL (RFC 4648 §5) इन्हें "-" और "_" से बदलता है और आमतौर पर पैडिंग हटा देता है, ताकि नतीजा URL, फ़ाइल नाम या JWT में बिना और एस्केपिंग के इस्तेमाल हो सके। एक वेरिएंट की उम्मीद करने वाला डिकोडर दूसरे को रिजेक्ट करेगा, और "वैध" टोकन के डिकोड न होने की यह सबसे आम वजह है।

आज़माएँ: URL एन्कोडर आज़माएँ: JWT डिकोडर

टेक्स्ट एन्कोड करना: कैरेक्टर सेट पर ध्यान दें

Base64 बाइट्स एन्कोड करता है, कैरेक्टर नहीं, इसलिए टेक्स्ट को पहले बाइट्स में बदलना पड़ता है — लगभग हमेशा UTF-8 में। हिंदी, अरबी और इमोजी मल्टी-बाइट सीक्वेंस बनते हैं; अगर एन्कोडर UTF-8 इस्तेमाल करे और डिकोडर Latin-1 मान ले (या उल्टा) तो आउटपुट बिगड़ा हुआ (mojibake) होगा। जब दो सिस्टम किसी Base64 स्ट्रिंग पर असहमत हों, तो कैरेक्टर सेट सबसे पहले जाँचने की चीज़ है।

आज़माएँ: Base64 एन्कोडर आज़माएँ: Hex एन्कोडर

डिकोडिंग क्यों फ़ेल होती है

  • गलत अल्फ़ाबेट — Base64URL स्ट्रिंग ("-", "_") स्टैंडर्ड डिकोडर को दी गई, या उल्टा।
  • पैडिंग गायब या ज़्यादा — कुछ एन्कोडर "=" छोड़ देते हैं, और सख़्त डिकोडर चार के गुणज की लंबाई माँगते हैं।
  • स्ट्रिंग के अंदर व्हाइटस्पेस या लाइन ब्रेक — MIME 76 कैरेक्टर पर लाइन रैप करता है; डिकोड करने से पहले हटाएँ।
  • डबल एन्कोडिंग — दो बार Base64-एन्कोड की गई स्ट्रिंग वैध दिखती है लेकिन डिकोड होकर और Base64 देती है।
  • यह Base64 था ही नहीं — hex, हैश या रैंडम टोकन मिलता-जुलता लग सकता है। Base64 ठीक 64 कैरेक्टर और "=" इस्तेमाल करता है, और पैडेड होने पर उसकी लंबाई चार का गुणज होती है।

आज़माएँ: Base64 डिकोडर

अक्सर पूछे जाने वाले सवाल

क्या Base64 सुरक्षित है?

नहीं। यह बिना key की उलटने योग्य एन्कोडिंग है। यह कोई गोपनीयता नहीं देता; उसके लिए एन्क्रिप्शन इस्तेमाल करें।

Base64 "=" या "==" पर क्यों ख़त्म होता है?

पैडिंग। इनपुट तीन-तीन बाइट के ग्रुप में प्रोसेस होता है; जब एक या दो बाइट बचते हैं, "==" या "=" जोड़ा जाता है ताकि डिकोडर असली लंबाई जाने।

Base64 आउटपुट कितना बड़ा होता है?

लगभग 33% — हर 3 बाइट 4 कैरेक्टर बनते हैं। 300 KB की इमेज लगभग 400 KB टेक्स्ट बन जाती है।

क्या Base64 इमेज या PDF एन्कोड कर सकता है?

हाँ — Base64 किसी भी बाइट्स पर काम करता है। इसी तरह data: URI HTML में इमेज एम्बेड करते हैं और फ़ाइलें JSON API के अंदर जाती हैं।

Base64 और hex में क्या फ़र्क़ है?

दोनों बाइट्स को टेक्स्ट के रूप में दिखाते हैं। Hex 16 कैरेक्टर इस्तेमाल करता है और साइज़ दोगुना करता है (प्रति बाइट 2 कैरेक्टर); Base64 64 कैरेक्टर इस्तेमाल करता है और साइज़ एक-तिहाई बढ़ाता है। Hex पढ़ने में आसान है; Base64 ज़्यादा कॉम्पैक्ट।

Base64 और URL एन्कोडिंग में क्या फ़र्क़ है?

URL (परसेंट) एन्कोडिंग सिर्फ़ URL में असुरक्षित कैरेक्टर को एस्केप करती है, सामान्य अक्षर वैसे ही रहते हैं। Base64 हर बाइट को फिर से एन्कोड करता है। ये अक्सर साथ आते हैं: क्वेरी पैरामीटर में जाने से पहले Base64 स्ट्रिंग को परसेंट-एन्कोडिंग चाहिए हो सकती है, जब तक URL-सेफ़ वेरिएंट न इस्तेमाल हो।

संदर्भ

  • RFC 4648: The Base16, Base32, and Base64 Data EncodingsIETF · 2006Base64 और Base64url अक्षरमाला, पैडिंग नियम और hex (Base16) एन्कोडिंग।
  • Base64 — MDN Glossary — MDNMDN Web Docs (Mozilla)ब्राउज़र में Base64: btoa/atob, URL-सेफ़ वेरिएंट और बाइनरी डेटा एन्कोड करने का साइज़ ओवरहेड।
  • RFC 2397: The "data" URL schemeIETF · 1998छोटी फ़ाइलें URL में data:<mediatype>;base64,<data> के रूप में कैसे एम्बेड होती हैं।

अभ्यास

Document upload API में Base64 की समस्याएँ पहचानें

आपका काम

आप एक सरकारी e-services platform (काल्पनिक) की Documents service को release 3.2 से पहले टेस्ट करते हैं। आवेदक mobile apps में supporting documents जोड़ते हैं, और apps हर फ़ाइल को JSON request के अंदर Base64 स्ट्रिंग के रूप में भेजते हैं; एक partner travel agency का system उसी API को सीधे HTTP Basic ऑथेंटिकेशन से call करता है; और receipt वाले ईमेल में एक link होता है जिसमें Base64 reference है। नीचे के material में requirement, API contract का एक अंश, platform के दो notes और staging पर जमा की गई छह observations हैं।

हर observation के लिए तय करें कि उसमें defect है या नहीं, उसके पीछे का Base64 नियम समझाएँ, और बताएँ कि fix कहाँ होना चाहिए; फिर ऐसे tests design करें जो अगली बार ये समस्याएँ पकड़ लें। काग़ज़-पेन, Base64 encoder और decoder (decoder की "टेक्स्ट को इस रूप में डिकोड करें" setting में Latin-1 भी है), URL decoder और एक boundary value analysis tool के साथ काम करें। 40–45 मिनट रखें; साइज़ के हिसाब में सिर्फ़ गुणा और भाग लगता है।

सामग्री
एक सरकारी e-services platform (काल्पनिक) - Documents service, release 3.2
Staging पर system testing

Requirement DOC-4
  आवेदक अपने application के साथ 5 MB (5,000,000 bytes) तक की PDF, JPG या PNG
  फ़ाइल जोड़ सकता है। इससे बड़ी फ़ाइल HTTP 413 और error FILE_TOO_LARGE
  ("फ़ाइल 5 MB से बड़ी है") के साथ reject होती है।

API contract (अंश)
  POST /api/v3/applications/{id}/documents       Content-Type: application/json
    content  फ़ाइल, Base64 में (RFC 4648, standard alphabet, padding के साथ)
    success  201, document id के साथ
    errors   400 INVALID_BASE64, 413 FILE_TOO_LARGE
  GET /api/v3/receipts?ref={ref}                 ref = 12 random bytes, Base64 में
  Callers: iOS और Android apps (upload से पहले 5 MB की सीमा जाँचते हैं)
           और एक partner travel agency का system (HTTP Basic authentication)

Platform notes
  API gateway 6,000,000 bytes से बड़ी हर request body को अपने HTTP 413 HTML page
  के साथ reject करता है, request के Documents service तक पहुँचने से पहले।
  Gateway की logging staging और production में एक जैसी configure है।

Sample upload (Base64 value छोटी की गई)
  {"fileName":"family-book.pdf","mimeType":"application/pdf","content":"JVBERi0xLjcK..."}
  Base64 value के बिना यह body 72 bytes की है।

Observations
O1  family-book.pdf, 4,800,000 bytes, app की जाँच पास करती है: HTTP 413 और
    gateway का HTML page। birth-certificate.pdf, 4,200,000 bytes: HTTP 201।
O2  Android app: हर upload 400 INVALID_BASE64 से fail; वही फ़ाइलें iOS से upload
    हो जाती हैं। Capture की गई Android request में "content" में हर 76
    कैरेक्टर के बाद \n है।
O3  दो ईमेल के receipt links:
      GET /api/v3/receipts?ref=Lm0x8Qp/Vt2aKc3Q   200, receipt download हुई
      GET /api/v3/receipts?ref=k7Qd2+fA9w1Z0LsE   400 "Invalid reference"
    दूसरी request का service log: ref = "k7Qd2 fA9w1Z0LsE"
O4  Gateway access log, partner की call:
      POST /api/v3/applications 201  Authorization: Basic YWdlbmN5MDc6VmlzYSNUZXN0MjY=
    Developer का comment: "रहने दें - header encoded है, इसे कोई पढ़ नहीं सकता।"
O5  Apps document owner का नाम एक header में भेजते हैं, Base64 में, क्योंकि
    header values ASCII रहनी चाहिए:   X-Doc-Owner: 2LPYp9ix2Kk=
    Back-office review screen पर owner का नाम दिखता है:   سارة
O6  तीन सफल uploads पर एक tester का note: "content corrupt लगता है - आख़िर में
    फ़ालतू = हैं और sizes फ़ाइलों से मेल नहीं खातीं।"
      फ़ाइल                     size (bytes)   content (कैरेक्टर)   आख़िर में
      passport-photo.png             48,211               64,284   ==
      salary-certificate.pdf        120,005              160,008   =
      lease-contract.jpg             96,300              128,400   (कोई = नहीं)
चरण
  1. Material की हर Base64 value डिकोड करें और लिखें कि उसमें क्या है।
  2. O1 के लिए सबसे बड़ी allowed फ़ाइल की Base64 लंबाई और request body का साइज़ निकालें, फिर वह सबसे बड़ी फ़ाइल जो gateway से निकल जाती है। बताएँ कि कौन-सी valid फ़ाइलें fail होती हैं और DOC-4 उनकी जगह क्या अपेक्षा करता है।
  3. O2 से O6 के लिए तय करें: defect है या नहीं, कौन-सा Base64 नियम इसे समझाता है, और fix कहाँ होना चाहिए (Android app, link बनाने वाला code, gateway, back office, या कहीं नहीं)।
  4. 2-value boundary value analysis से फ़ाइल साइज़ की test values निकालें (हर boundary value और बगल वाले partition में उसकी सबसे नज़दीकी value टेस्ट करें: यहाँ सबसे बड़ा accept होने वाला साइज़ और उससे एक byte बड़ा साइज़), requirement की boundary और gateway की boundary दोनों के लिए, और ऐसे साइज़ जोड़ें जो padding का हर case चलाएँ।
  5. content field और receipt reference के negative tests उनके expected results के साथ लिखें, और वे सवाल भी जो आप API owner को भेजेंगे।
मॉडल उत्तर दिखाएँ
मॉडल उत्तर

डिकोड की गई values। JVBERi0xLjcK डिकोड होकर %PDF-1.7 और उसके बाद एक line break देता है: यही header PDF फ़ाइल की शुरुआत में होता है, यानी content में सच में फ़ाइल के बाइट्स हैं। YWdlbmN5MDc6VmlzYSNUZXN0MjY= डिकोड होकर agency07:Visa#Test26 देता है, यानी partner का username और password। 2LPYp9ix2Kk= के बाइट्स D8 B3 D8 A7 D8 B1 D8 A9 को UTF-8 में पढ़ें तो अरबी नाम سارة (सारा) मिलता है, और यही बाइट्स Latin-1 में पढ़ें तो ठीक سارة। दोनों receipt references डिकोड होकर 12-12 random bytes देते हैं; उनमें पढ़ने लायक़ कुछ होने की उम्मीद नहीं है।

O1: gateway configuration में defect। Base64 हर 3 बाइट को 4 कैरेक्टर में बदलता है और आख़िरी group को ऊपर round करता है। सबसे बड़ी allowed फ़ाइल, 5,000,000 bytes, 1,666,667 groups है, इसलिए content 6,666,668 कैरेक्टर का है (एक "=" padding के साथ) और body 6,666,668 + 72 = 6,666,740 bytes, जो gateway की 6,000,000 की सीमा से ऊपर है। Gateway से निकलने वाली सबसे बड़ी फ़ाइल: content के लिए 6,000,000 − 72 = 5,999,928 कैरेक्टर बचते हैं; 5,999,928 ÷ 4 = 1,499,982 पूरे groups; 1,499,982 × 3 = 4,499,946 bytes। इसलिए sample की तरह JSON के 72 bytes के साथ 4,499,947 से 5,000,000 bytes तक की हर valid फ़ाइल reject होती है (4,800,000 bytes की family-book.pdf को 6,400,072 bytes की body चाहिए, जबकि 4,200,000 bytes की birth-certificate.pdf 5,600,000 कैरेक्टर में encode होती है और निकल जाती है), और आवेदक को काम का error नहीं, gateway का HTML page मिलता है। सीमा से बड़ी फ़ाइलों को भी गलत जवाब मिलता है: partner का system, जिसके आगे app वाली जाँच नहीं है, 5,000,001 bytes की फ़ाइल भेजे तो वह service तक पहुँचती ही नहीं, इसलिए DOC-4 का माँगा हुआ FILE_TOO_LARGE error कभी नहीं लौटता।

ISTQB की भाषा में failure है valid फ़ाइल पर 413; defect है request body की ऐसी सीमा जो encoded request के बजाय raw फ़ाइल के साइज़ के हिसाब से तय की गई। इसे gateway configuration के ख़िलाफ़ report करें, DOC-4 को test basis बनाकर। Fix का फ़ैसला team का है: सीमा को सबसे बड़ी encoded body से ऊपर ले जाना, लंबे file names की गुंजाइश के साथ, या फ़ाइलों को JSON में Base64 के बजाय binary रूप में upload करना (जैसे multipart/form-data), जिससे एक-तिहाई का overhead भी ख़त्म हो जाता है। Developers के लिए एक note जोड़ें: 5,000,000 और 5,000,001 bytes दोनों 6,666,668 कैरेक्टर में encode होते हैं, इसलिए साइज़ का नियम डिकोड किए गए बाइट्स पर जाँचना चाहिए, Base64 स्ट्रिंग की लंबाई पर कभी नहीं।

O2: Android app में defect। हर 76 कैरेक्टर पर line break MIME-style wrapping है। RFC 4648 §3.1 कहता है कि encoders line breaks न जोड़ें, जब तक Base64 इस्तेमाल करने वाला specification ऐसा न माँगे, और contract नहीं माँगता; §3.3 कहता है कि डिकोडर alphabet से बाहर के कैरेक्टर reject करे, जब तक specification कुछ और न कहे। इसलिए service का 400 INVALID_BASE64 सही है, और iOS दिखाता है कि फ़ाइलें ख़ुद ठीक हैं। दोनों तरह के डिकोडर आप साथ-साथ देख सकते हैं: Base64 encoder में "पंक्ति रैप" को "76 कैरेक्टर (MIME)" पर रखकर कोई छोटी फ़ाइल encode करें और नतीजा Base64 decoder में paste करें, जो tolerant है: वह line breaks को नज़रअंदाज़ करता है और बताता है कि कितने whitespace कैरेक्टर छोड़े। Documents service strict है, जैसा RFC default रूप से माँगता है। Fix: Android encoder value को एक ही line में बनाए। API owner से कहें कि contract में साफ़ लिखे: "एक line, कोई whitespace नहीं"।

O3: receipt link बनाने के तरीके में defect। दूसरे reference में "+" है। Link standard Base64 को बिना percent-encoding के query string में रखता है, और service query string को form-encoding के नियमों से पढ़ती है, जिनमें "+" का मतलब space है; उसे k7Qd2 fA9w1Z0LsE मिलता है और वह उसे reject कर देती है। URL decoder इसे दोहराता है: "+ को स्पेस के रूप में डिकोड करें" चालू हो तो k7Qd2+fA9w1Z0LsE बदलकर k7Qd2 fA9w1Z0LsE बनता है। पहला reference सिर्फ़ इसलिए चलता है कि उसमें "+" नहीं है; उसका "/" query string में मान्य है, लेकिन अगर reference कभी path में गया तो route तोड़ देगा। References random bytes हैं, इसलिए कौन-सा link fail होगा यह भी random लगता है, और इसी वजह से ऐसे defects अक्सर intermittent कहकर report होते हैं। Fix: reference के लिए Base64URL (RFC 4648 §5), ताकि k7Qd2-fA9w1Z0LsE और Lm0x8Qp_Vt2aKc3Q को कोई escaping न चाहिए; या value को percent-encode करना ताकि "+" बने %2B (URL encoder यह दिखाता है), हालाँकि इसे भूल जाना आसान है। ईमेल से पहले भेजे जा चुके links fix के बाद भी चलने चाहिए: पूछें कि पुराने references कैसे स्वीकार होंगे।

O4: security defect, और छहों में सबसे गंभीर, क्योंकि यह credentials उजागर करता है। Header कुछ सेकंड में डिकोड होकर agency07:Visa#Test26 देता है: gateway log partner का password पढ़ने लायक़ रूप में रखता है, logs पढ़ सकने वाले हर व्यक्ति के लिए, और production भी इसी तरह log करता है। Developer का comment गलत है: Base64 बिना key की एन्कोडिंग है, एन्क्रिप्शन नहीं, और HTTPS Basic credentials को सिर्फ़ रास्ते में बचाता है, log में लिखे जाने के बाद नहीं। इसे high severity के साथ report करें, और report में username लिखें पर password छिपा दें। अपेक्षित fix: gateway log में, और headers दर्ज करने वाले हर दूसरे log या monitoring tool में, Authorization header को mask करना या हटाना, और उजागर हुए credential को बदलना। Confirmation test: partner की call दोहराएँ और जाँचें कि log में कोई credential नहीं दिखता; regression tests में secrets ले जाने वाले दूसरे headers भी जाँचें, जैसे API keys और Bearer tokens।

O5: back office में defect। Apps सही हैं: 2LPYp9ix2Kk= नाम سارة का UTF-8 encoding है (4 कैरेक्टर, 8 बाइट)। Back office डिकोड किए गए बाइट्स को Latin-1 से टेक्स्ट बनाता है, हर बाइट का एक कैरेक्टर, तो D8 बनता है Ø और B3 बनता है ³, और नतीजा سارة; Base64 decoder में "टेक्स्ट को इस रूप में डिकोड करें" को "Latin-1 / बाइनरी स्ट्रिंग" पर रखने से यही ठीक-ठीक दोहराया जा सकता है। Ø या Ù की कतार, जिसमें हर एक के बाद कोई और symbol हो, Latin-1 में पढ़े गए अरबी UTF-8 का आम निशान है। Fix: डिकोड किए गए बाइट्स को UTF-8 में पढ़ना। Confirmation test और regression suite के लिए test data: एक अरबी नाम, देवनागरी में एक हिंदी नाम (UTF-8 में हर कैरेक्टर 3 बाइट), accent वाला Latin नाम जैसे José (é 2 बाइट), field अनुमति दे तो emoji वाला नाम (4 बाइट), और सिर्फ़ ASCII वाला नाम, जो बिना बदले रहना चाहिए।

O6: defect नहीं। Padding फ़ाइल के साइज़ से तय होती है, क्योंकि Base64 तीन-तीन बाइट के groups में काम करता है: 48,211 को 3 से भाग देने पर शेष 1 बचता है, इसलिए value "==" पर ख़त्म होती है; 120,005 पर शेष 2, इसलिए "="; 96,300 पर शेष 0, इसलिए कोई padding नहीं। (जल्दी जाँचने का तरीका: किसी संख्या को 3 से भाग देने पर वही शेष बचता है जो उसके अंकों के जोड़ को 3 से भाग देने पर।) लंबाई होती है 4 × (साइज़ ÷ 3, ऊपर round करके): 16,071 × 4 = 64,284, 40,002 × 4 = 160,008 और 32,100 × 4 = 128,400, यानी हर फ़ाइल से लगभग एक-तिहाई ज़्यादा, जैसा होना चाहिए। Note को इस हिसाब के साथ "defect नहीं" कहकर बंद करें, और तीनों फ़ाइलें रख लें: साथ मिलकर वे padding के तीनों cases cover करती हैं।

फ़ाइल साइज़ की test values (2-value BVA)। Requirement की boundary: 5,000,000 bytes, 201 के साथ accept, और 5,000,001 bytes, 413 और FILE_TOO_LARGE के साथ reject; दोनों को सिर्फ़ app से नहीं, सीधे API पर भी भेजें, जैसे partner का system भेजता है। Sample file name के लिए gateway की boundary, जो एक technical boundary है और requirement में नहीं लिखी: 4,499,946 bytes (body ठीक 6,000,000, accept) और 4,499,947 bytes (body 6,000,004, आज gateway reject करता है, defect fix होने के बाद accept)। Padding cases: तीन साइज़ जिन्हें 3 से भाग देने पर शेष 0, 1 और 2 बचे, जैसे O6 की फ़ाइलें। Gateway boundary को सबसे लंबे allowed file name के साथ भी चलाएँ, क्योंकि JSON का हर extra बाइट gateway से निकलने वाली सबसे बड़ी फ़ाइल को घटाता है, और पूछें कि खाली फ़ाइल के लिए DOC-4 क्या अपेक्षा करता है। Fix के बाद 4,499,947 और 5,000,000 को regression suite में रखें।

मौजूदा contract के हिसाब से content के negative tests, हर एक में अपेक्षित 400 INVALID_BASE64 और कुछ भी store नहीं: value के अंदर line breaks या spaces; Base64URL के कैरेक्टर "-" या "_"; alphabet से बाहर का कोई कैरेक्टर, जैसे "*"; ऐसी लंबाई जो 4 का गुणज न हो (padding हटाकर); और value के बीच में "="। दो बार encode की गई फ़ाइल वैध Base64 है जिसके डिकोड किए गए बाइट्स ख़ुद Base64 टेक्स्ट हैं (यह JVBERi0 की जगह SlZCRVJp से शुरू होती है): अगर service फ़ाइल के content को mimeType से मिलाती है तो इसे PDF न होने के कारण reject होना चाहिए, इसलिए पूछें कि वह मिलाती है या नहीं। Receipt reference के लिए: "+" और "/" वाले references, और अगर references की लंबाई बदल सकती है तो "=" वाले भी; space वाला reference; percent-encoded reference (%2B); और सही format का पर अनजान reference, जिस पर client error आना चाहिए, 500 कभी नहीं (अंश में नहीं लिखा कि कौन-सा, इसलिए पूछें)।

API owner के लिए सवाल: service गायब padding और whitespace को स्वीकार करे या reject, और क्या contract यह साफ़ लिख सकता है? सबसे लंबा allowed file name कितना है, क्योंकि वह gateway boundary को खिसकाता है? क्या service जाँचती है कि डिकोड किए गए बाइट्स mimeType से मेल खाते हैं? क्या receipt references Base64URL पर जाएँगे, और पहले भेजे गए links कैसे चलते रहेंगे? और 5 MB तक की फ़ाइलों के लिए, एक-तिहाई के overhead के साथ, क्या JSON के अंदर Base64 सही channel है भी?

अगर आपके numbers अलग हैं, तो जाँचें कि encoded लंबाई निकालते समय आपने groups की गिनती ऊपर round की और gateway से निकलने वाली सबसे बड़ी फ़ाइल निकालते समय नीचे, और JSON के 72 bytes जोड़े।

इस topic में आपकी प्रगति

QA रोडमैप का हिस्सा

इस गाइड में बताए गए टूल्स

टेक्स्ट या फ़ाइलों को अपने ब्राउज़र में ही Base64 (स्टैंडर्ड या URL-सुरक्षित) में एन्कोड करें।

एन्कोडिंग

Base64 या Base64url स्ट्रिंग को टेक्स्ट में डिकोड करें, पैडिंग अपने आप ठीक होने के साथ।

एन्कोडिंग

URL, क्वेरी स्ट्रिंग और फ़ॉर्म डेटा में सुरक्षित इस्तेमाल के लिए टेक्स्ट को percent-encode करें।

एन्कोडिंग

टेक्स्ट को हेक्साडेसिमल बाइट (UTF-8) में बदलें, मनचाहे सेपरेटर और केसिंग के साथ।

एन्कोडिंग

JWT का हेडर और पेलोड डिकोड करें, क्लेम जाँचें और एक्सपायरी देखें — पूरी तरह आपके ब्राउज़र में।

सुरक्षा

और गाइड

और गाइड
सुरक्षा

JWT क्या है? JSON Web Token समझें

JWT आसान भाषा में: JSON Web Token के तीन हिस्से, exp और sub जैसे क्लेम, डिकोड और वेरिफ़ाई कैसे करें, डिकोड करना वेरिफ़ाई क्यों नहीं, और सिक्योरिटी।

5 मिनट पढ़ने का समय
JSON और डेटा

JSON क्या है?

JSON आसान भाषा में: यह क्या है, छह वैल्यू टाइप, वे सिंटैक्स नियम जिनमें लोग अटकते हैं, इसे फ़ॉर्मेट और वैलिडेट कैसे करें, और XML व YAML से इसकी तुलना।

5 मिनट पढ़ने का समय
यूटिलिटीज़

UUID क्या है? v4 बनाम v7, UUID बनाम GUID और ULID

UUID समझें: 128-बिट फ़ॉर्मेट, v4 बनाम v7, डेटाबेस key के लिए v7 बेहतर क्यों, UUID बनाम GUID बनाम ULID, कॉलिज़न की संभावना, और जनरेट-वैलिडेट कैसे करें।

5 मिनट पढ़ने का समय
वेब

HTTP स्टेटस कोड समझें

HTTP स्टेटस कोड की हर क्लास उन कोड के साथ जो असल में मिलते हैं — 200, 301, 400, 401, 403, 404, 422, 429, 500, 502, 503, 504 — वजह और कौन-सा लौटाएँ।

5 मिनट पढ़ने का समय
यूटिलिटीज़

Cron एक्सप्रेशन समझें

Cron एक्सप्रेशन फ़ील्ड-दर-फ़ील्ड: मिनट, घंटा, दिन, महीना, वीकडे, *, /, - और , ऑपरेटर, आम शेड्यूल, टाइम ज़ोन और क्लासिक गलतियाँ।

6 मिनट पढ़ने का समय
यूटिलिटीज़

रेगुलर एक्सप्रेशन (Regex) शुरुआती गाइड

Regex शुरू से सीखें: कैरेक्टर क्लास, क्वांटिफ़ायर, एंकर, ग्रुप और फ़्लैग, ईमेल, फ़ोन और तारीख़ के रेडी पैटर्न, और regex सुरक्षित तरीके से टेस्ट करना।

5 मिनट पढ़ने का समय