Base64

Da Wikipedia, l'enciclopedia libera.

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.

[modifica] 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.

[modifica] Esempio di conversione

Dati 3 byte di valore 1, 2, 3, partendo dalla loro rappresentazione binaria, applichiamo l'algoritmo:

Valori decimali:                          1           2           3
                                          |           |           |
Rappresentazione binaria:             00000001    00000010    00000011
                                        /    \     /    \     /    \
Suddivisione in gruppi da 6 bit:     000000  01  0000  0010  00  000011
                                     |----|  |------|  |------|  |----|
I 4 valori dedotti:                  000000   010000    001000   000011
                                       \/       \/        \/       \/
Il valore decimale:                     0       16         8        3
                                        |        |         |        |
Il valore convertito:                   A        Q         I        D

Quindi la sequenza di valori (1, 2, 3) viene convertita nella sequenza (AQID)

Nel caso in cui i bit non siano multipli di 6, vengono inseriti bit nulli (0) alla fine, e nella codifica viene aggiunto un simbolo '=' per ogni coppia di bit mancanti (massimo da 0 a 2 coppie, basta fare un piccolo ragionamento matematico)

Quindi, preso il singolo valore (1), esso viene convertito nella sequenza (AQ==), il singolo valore (2) viene convertito in (Ag==), mentre la sequenza (1, 2) diventa (AQI=)


Una 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;
}
Estratto da "http://it.wikipedia.org/wiki/Base64"
Strumenti personali