Baza64

Această intrare sau secțiune despre programare nu citează sursele necesare sau cei prezenți sunt insuficienți . Puteți îmbunătăți această intrare adăugând citate din surse de încredere în conformitate cu liniile directoare privind utilizarea surselor .

Base64 este un sistem de codificare care permite traducerea datelor binare în șiruri de text ASCII, reprezentând datele pe baza a 64 de caractere ASCII diferite.

Este utilizat în principal ca codificare a datelor binare în e-mailuri , pentru a converti datele în format ASCII .

Algoritmul

Algoritmul de conversie împarte fișierul în grupuri de 6 biți , care, prin urmare, pot conține valori de la 0 la 63. Fiecare valoare posibilă este convertită într-un caracter ASCII în conformitate cu următorul tabel:

Setul de 64 de caractere ales pentru a reprezenta cele 64 de valori (0-63) variază în funcție de implementarea aleasă. Obiectivul este de obicei alegerea a 64 de caractere care sunt comune pentru majoritatea codificărilor și care pot fi, de asemenea, tipărite. Celelalte variante, de obicei derivate din Base64, împărtășesc aceste proprietăți, dar diferă în alegerea ultimelor două caractere; de exemplu, varianta URL și numele fișierului sigur ( RFC 4648 / Base64URL), utilizați „-” și „_”.

Algoritmul determină creșterea dimensiunii datelor cu 33%, deoarece fiecare grup de 3 octeți este convertit în 4 caractere. Aceasta presupune că un întreg octet este utilizat pentru a reprezenta un caracter.

Dacă s-ar folosi 7 biți pentru a reprezenta caractere ASCII (care ar fi suficiente) și nu 8, creșterea dimensiunii ar fi doar de 17%. Cu toate acestea, deoarece 8 biți sunt folosiți în mod convențional pentru a reprezenta caractere ASCII (7 pentru caracter, lăsând bitul rămas nul), atunci se obține creșterea dimensiunii descrisă mai sus.

Exemplu de codare

Dat fiind 3 octeți care conțin valorile A, B, C, pornind de la reprezentarea lor binară , aplicăm algoritmul:

 Reprezentare ASCII: ABC
                                          | | |
Reprezentare binară: 01000001 01000010 01000011
                                        / \ / \ / \
Subdiviziune în grupuri pe 6 biți: 010000 01 0100 0010 01 000011
                                     | ---- | \ ------ / \ ------ / | ---- |
Cele 4 valori deduse: 010000 010100 001001 000011
                                       \ / \ / \ / \ /
Valoarea zecimală: 16 20 9 3
                                        | | | |
Valoarea codificată: QUJD

Apoi, secvența de valori (ABC) este convertită în secvența (QUJD).

Dacă lungimea mesajului original nu este un multiplu de 3 octeți, numărul de biți care formează rezultatul nu va fi un multiplu de 6. Se vor introduce apoi biți nul (0) la sfârșit (4 sau 2) și adăugat la valoarea codificată de la 0 la 2 '=' simboluri (caracter de umplere) suficient pentru a ajunge la un multiplu de 4 simboluri. Fiecare caracter de umplere indică, prin urmare, adăugarea unei perechi de biți nuli. Cu toate acestea, umplerea nu este esențială pentru decodare și unele implementări nu o folosesc. Completarea este esențială doar dacă doriți să concatenați mesajele codate.

Apoi, luând un singur octet de valoare (A), este convertit în secvență (QQ ==), valoarea unică (B) este convertită în (Qg ==), în timp ce secvența (AB) devine (QUI =) .

Posibilă rutină de conversie

 conv. uniune
 {
 	nesemnat int l ;
 	octeti struct
 	{
 		char b1 ;
 		char b2 ;
 		char b3 ;
 		char b4 ;
 	} b ;
 };
 
 convertit char (char c)
 {
 	if ( c == 63 )
 		retur 47 ;
 	altfel dacă ( c == 62 )
 		retur 43 ;
 	altfel dacă ( c > = 52 )
 		retur c - 4 ;
 	altfel dacă ( c > = 26 )
 		returnează c + 71 ;
 	altceva
 		returnează c + 65 ;
 }
 
 unsigned int toBase64 ( char b1 , char b2 , char b3 )
 {
 	conv src , dest ;
 	src . b . b1 = b3 ;
 	src . b . b2 = b2 ;
 	src . b . b3 = b1 ;
 	src . b . b4 = 0 ;
 	//conv.l == b4 b3 b2 b1
 	dest . b . b1 = convert ( src . b . b1 & 0x3f );
 	src . l = src . 1 >> 6 ; 
 	dest . b . b2 = convert ( src . b . b1 & 0x3f );
 	src . l = src . 1 >> 6 ;
 	dest . b . b3 = convert ( src . b . b1 & 0x3f );
 	src . l = src . 1 >> 6 ;
 	dest . b . b4 = convert ( src . b . b1 & 0x3f );
 
 	întoarce dest . l ;
 }

Variante

Există variante ale acestei codificări, care diferă în principal prin alegerea celor două caractere utilizate pentru a reprezenta valorile 62 și 63 și pentru „caracterul de umplere”. În special, varianta care folosește caracterele "-" și "_" ca valori 62 și 63 (în loc de "+" și "/") și nu folosește umplutura este utilizată pe scară largă; această variantă este deosebit de utilă atunci când șirul codificat trebuie utilizat într-un URL sau un nume de fișier.

linkuri externe

• Implementarea C pentru codificarea Base64
• Decodare Base64 Decodare Base64

Portalul de matematică : accesați intrările Wikipedia care se ocupă de matematică