Base64

Un alphabet de 65 caractères est utilisé pour permettre la représentation de 6 bits par un caractère. Le 65^e caractère (signe « = ») n'est utilisé qu'en complément final dans le processus de codage d'un message.

Ce processus de codage consiste à coder chaque groupe de 24 bits successifs de données par une chaîne de 4 caractères. On procède du début à la fin, en concaténant 3 octets pour créer un seul groupement de 24 bits (8 bits par octet). Ils sont alors séparés en 4 nombres de seulement 6 bits (qui en binaire ne permettent que 64 combinaisons). Chacune des 4 valeurs est enfin représentée (codée) par un caractère de l'alphabet retenu. (Table ci-dessous.)

Ainsi 3 octets quelconques sont remplacés par 4 caractères, choisis pour être compatibles avec tous les systèmes existants.

Chaque valeur (chaque groupe de 6 bits) est utilisée comme index dans la table ci-dessous. Le caractère correspondant est indiqué dans la colonne codage.

        Valeur Codage         Valeur Codage         Valeur Codage         Valeur Codage
      0 000000 A           17 010001 R           34 100010 i           51 110011 z
      1 000001 B           18 010010 S           35 100011 j           52 110100 0
      2 000010 C           19 010011 T           36 100100 k           53 110101 1
      3 000011 D           20 010100 U           37 100101 l           54 110110 2
      4 000100 E           21 010101 V           38 100110 m           55 110111 3
      5 000101 F           22 010110 W           39 100111 n           56 111000 4
      6 000110 G           23 010111 X           40 101000 o           57 111001 5
      7 000111 H           24 011000 Y           41 101001 p           58 111010 6
      8 001000 I           25 011001 Z           42 101010 q           59 111011 7
      9 001001 J           26 011010 a           43 101011 r           60 111100 8
     10 001010 K           27 011011 b           44 101100 s           61 111101 9
     11 001011 L           28 011100 c           45 101101 t           62 111110 +
     12 001100 M           29 011101 d           46 101110 u           63 111111 /
     13 001101 N           30 011110 e           47 101111 v
     14 001110 O           31 011111 f           48 110000 w        (complément) =
     15 001111 P           32 100000 g           49 110001 x
     16 010000 Q           33 100001 h           50 110010 y

Un traitement spécial est effectué si moins de 24 bits sont disponibles à la fin de la séquence de données à coder (elle n'a pas forcément une taille multiple de 24 bits). Dans un tel cas, des zéros sont ajoutés à la droite des données initiales pour aller vers le multiple de 6 bits le plus proche. Chaque paquet de 6 bits est converti dans l'alphabet. Puis on ajoute des caractères « = » complémentaires pour former quand même 4 caractères.

Puisque les données d'entrée doivent être constituées d'un nombre entier d'octets, seuls trois cas sont possibles en fin de séquence :

• il reste exactement 3 octets à coder (24 bits), alors on obtient directement 4 caractères sans traitement complémentaire ;
• il reste seulement 2 octets (16 bits) à coder, alors on ajoute à droite 2 bits à zéros pour former 3 caractères de l'alphabet (3×6 = 16+2 = 18 bits) suivis d'un quatrième caractère « = » en complément ;
• il reste un seul octet (8 bits) à coder, alors on ajoute à droite 4 bits à zéros pour former 2 caractères de l'alphabet (2×6 = 8+4 = 12 bits) suivis de deux caractères « = » en complément.

Ce codage augmente la taille des données : la taille des données est augmentée d'au moins un tiers. Les caractères « blancs » (espace, tabulation, retour à la ligne) augmentent encore plus la taille.

Avec ce codage, même les caractères lisibles dans les données d'origine sont encodés de manière illisible. Si la majorité des caractères d'un texte initial sont déjà lisibles, on peut envisager de ne coder que les caractères problématiques. Voir par exemple pour cela l'encodage Quoted-Printable.

L’intérêt de l'encodage base64 ne se trouve donc pas dans la représentation de données textuelles, mais surtout dans la représentation de données binaires.

Lorsque l’on veut représenter des données binaires (une image, un exécutable) dans un document textuel, tel qu’un courriel, la transcription hexadécimale en ASCII des octets multiplierait la taille par deux, l'encodage en base64 permet de limiter cette augmentation.

Par ailleurs, le reproche fait sur la lisibilité des données tombe de lui-même dans ces conditions : les données binaires n’ont pas vocation à être compréhensibles sans interprétation par un logiciel dédié (cas d’une image, par exemple).

Le document RFC 4648 prévoit une alternative pour un encodage compatible avec les noms de fichiers et les URI. En effet les caractères 62 (+) et 63 (/) peuvent poser problème avec certains systèmes de fichiers et dans les URI. La solution retenue consiste à remplacer ces caractères respectivement par un moins (-) et un souligné (_). Le caractère de complément reste le « = », mais peut être ignoré. Ce système est par exemple utilisé pour la réduction d'URL.

        Valeur Codage         Valeur Codage         Valeur Codage         Valeur Codage
      0 000000 A           17 010001 R           34 100010 i           51 110011 z
      1 000001 B           18 010010 S           35 100011 j           52 110100 0
      2 000010 C           19 010011 T           36 100100 k           53 110101 1
      3 000011 D           20 010100 U           37 100101 l           54 110110 2
      4 000100 E           21 010101 V           38 100110 m           55 110111 3
      5 000101 F           22 010110 W           39 100111 n           56 111000 4
      6 000110 G           23 010111 X           40 101000 o           57 111001 5
      7 000111 H           24 011000 Y           41 101001 p           58 111010 6
      8 001000 I           25 011001 Z           42 101010 q           59 111011 7
      9 001001 J           26 011010 a           43 101011 r           60 111100 8
     10 001010 K           27 011011 b           44 101100 s           61 111101 9
     11 001011 L           28 011100 c           45 101101 t           62 111110 - (minus)
     12 001100 M           29 011101 d           46 101110 u           63 111111 _ (underline)
     13 001101 N           30 011110 e           47 101111 v
     14 001110 O           31 011111 f           48 110000 w        (complément) =
     15 001111 P           32 100000 g           49 110001 x
     16 010000 Q           33 100001 h           50 110010 y

Afin de surmonter l'invariance incompatible de Base64 due à l'inclusion de plus de deux caractères "classe symbolique" (+, /, =, etc.) dans le contenu de sortie, un schéma de codage Base62x non chiffré pour le contenu de sortie a été introduit dans le domaine du génie logiciel. Base62x est considérée comme une version améliorée de Base64 non signée.

Prenons le groupe de 3 caractères ASCII « Hi! ». Ci-dessous la première ligne indique en binaire l'équivalence de ces 3 octets. La transformation consiste comme on peut le voir, à séparer les bits pour former en sortie 4 groupes de 6 bits :

01001000 01101001 00100001 ⇔ 010010 000110 100100 100001

Les 4 groupes de 6 bits en sortie nous donnent les valeurs 18, 6, 36 et 33. Ainsi en suivant la correspondance de la table indexée nous obtenons les 4 caractères « SGkh ».

Avec la commande base64 sous Linux :

$ echo -n 'Hi!' | base64

SGkh

Si nous prenons une chaine de caractères qui n'a pas un nombre de bits multiple de 24 (l'encodage se faisant par paquet de 4 x 6 bits = 24 bits), par exemple la chaîne « Salut » :

         S        a        l        u        t
         01010011 01100001 01101100 01110101 01110100 
    ⇔    010100 110110 000101 101100 011101 010111 010000 ?????? (nombre de bits multiple de 24)
    ⇔    U      2      F      s      d      X      Q      =

La procédure d'encodage est la suivante: Le dernier groupe "0100" est complété par deux "0" pour avoir une taille de 6 bits. Le symbole correspondant dans la table est la lettre "Q". Puis, pour obtenir un nombre de bits multiple de 24, il faut également ajouter un groupe de 6 bits "de remplissage", qui est symbolisé par "=".

Nous obtenons ainsi « Salut » ⇒ « U2FsdXQ= ».

         B        o        n        j        o        u        r
         01000010 01101111 01101110 01101010 01101111 01110101 01110010 
    ⇔    010000 100110 111101 101110 011010 100110 111101 110101 011100 100000 ?????? ???????
    ⇔    Q      m      9      u      a      m      9      1      c      g      =      =
                                                                         (g vaut 100000)

Nous obtenons ainsi « Bonjour » ⇒ « Qm9uam91cg== ».

$ openssl enc -base64 -in monfichier.txt -out monfichier.b64

$ openssl enc -d -base64 -in monfichier.b64 -out monfichier.txt

• Portail de l’informatique