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.

L'algoritmo[modifica | modifica sorgente]

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

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 e 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[modifica | modifica sorgente]

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