Base64

Da Wikipedia, l'enciclopedia libera.

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

Viene usato soprattutto nella spedizione dell'email, per convertire dati binari in formato ASCII.

[modifica] L'algoritmo

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

NUM    ASCII
 0      A       16      Q       32      g       48      w
 1      B       17      R       33      h       49      x
 2      C       18      S       34      i       50      y
 3      D       19      T       35      j       51      z
 4      E       20      U       36      k       52      0
 5      F       21      V       37      l       53      1
 6      G       22      W       38      m       54      2
 7      H       23      X       39      n       55      3
 8      I       24      Y       40      o       56      4
 9      J       25      Z       41      p       57      5
10      K       26      a       42      q       58      6
11      L       27      b       43      r       59      7
12      M       28      c       44      s       60      8
13      N       29      d       45      t       61      9
14      O       30      e       46      u       62      +
15      P       31      f       47      v       63      /

L'algoritmo causa un aumento delle dimensioni del file del 33%, poiché, un gruppo di 3 byte, viene convertito in 4 caratteri.

[modifica] Esempio di conversione

Abbiamo i numeri 1, 2, 3, partendo dalla loro rappresentazione binaria, applichiamo l'algoritmo:

     1           2           3
 00000001    00000010    00000011
   /    \     /    \     /    \
000000  01  0000  0010  00  000011
|----|  |------|  |------|  |----|
000000   010000    001000   000011
   0       16         8        3
   A        Q         I        D

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;
}