Base64

Base64 è un sistema di numerazione posizionale che usa 64 simboli.

Viene usato principalmente come codifica di dati binari nelle e-mail, per convertire i dati nel formato ASCII.

L'algoritmo

L'algoritmo che effettua la conversione suddivide il file in gruppi da 6 bit, i quali possono quindi contenere valori da 0 a 63. Ogni possibile valore viene convertito in un carattere ASCII secondo la seguente tabella:

Valore ASCII 0 A 1 B 2 C 3 D 4 E 5 F 6 G 7 H 8 I 9 J 10 K 11 L 12 M 13 N 14 O 15 P

Valore ASCII 16 Q 17 R 18 S 19 T 20 U 21 V 22 W 23 X 24 Y 25 Z 26 a 27 b 28 c 29 d 30 e 31 f

Valore ASCII 32 g 33 h 34 i 35 j 36 k 37 l 38 m 39 n 40 o 41 p 42 q 43 r 44 s 45 t 46 u 47 v

Valore ASCII 48 w 49 x 50 y 51 z 52 0 53 1 54 2 55 3 56 4 57 5 58 6 59 7 60 8 61 9 62 + 63 /

L'algoritmo causa un aumento delle dimensioni dei dati del 33%, poiché ogni gruppo di 3 byte viene convertito in 4 caratteri. Questo supponendo che per rappresentare un carattere si utilizzi un intero byte.

Esempio di conversione

Dati 3 byte che contengono i valori A, B, C, partendo dalla loro rappresentazione binaria, applichiamo l'algoritmo:

Valori decimali:                          A           B           C
                                          |           |           |
Rappresentazione binaria:             01000001    01000010    01000011
                                        /    \     /    \     /    \
Suddivisione in gruppi da 6 bit:     010000  01  0100  0010  01  000011
                                     |----|  |------|  |------|  |----|
I 4 valori dedotti:                  010000   010100    001001   000011
                                       \/       \/        \/       \/
Il valore decimale:                    16       20         9        3
                                        |        |         |        |
Il valore convertito:                   Q        U         J        D

Quindi la sequenza di valori (ABC) viene convertita nella sequenza (QUJD)

Nel caso in cui i bit non siano multipli di 6, vengono inseriti bit nulli (0) alla fine, e nella codifica vengono aggiunti da 0 a 2 simboli '=' (padding character) sufficienti a raggiungere un multiplo di 4 simboli. Ciascun padding character indica pertanto l'aggiunta di una coppia di bit nulli. Il padding non è comunque indispensabile per la decodifica. Alcune implementazioni non lo utilizzano.

Quindi, preso un singolo byte di valore (A), esso viene convertito nella sequenza (QQ==), il singolo valore (B) viene convertito in (Qg==), mentre la sequenza (AB) diventa (QUI=)

Possibile routine di conversione

 union conv
 {
        unsigned int l;
        struct bytes
        {
                char b1;
                char b2;
                char b3;
                char b4;
        } b;
 };
 
 char convert (char c)
 {
        if (c == 63)
                return 47;
        else if (c == 62)
                return 43;
        else if (c >= 52)
                return c - 4;
        else if (c >= 26)
                return c + 71;
        else
                return 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.l >> 6; 
        dest.b.b2 = convert(src.b.b1 & 0x3f);
        src.l = src.l >> 6;
        dest.b.b3 = convert(src.b.b1 & 0x3f);
        src.l = src.l >> 6;
        dest.b.b4 = convert(src.b.b1 & 0x3f);
 
        return dest.l;
 }

Collegamenti esterni

• Implementazione in C per la codifica in Base64
• Online Base64 text and file encoder/decoder
• Online Base64 encoder/decoder
• Online base64 encode/decode javascript+html5

Portale Matematica: accedi alle voci di Wikipedia che trattano di matematica