Implémentation JAVA de base64_encode et base64_decode

Base64 est l'une des méthodes de codage les plus courantes pour transmettre du code d'octet de 8 bits sur Internet. Vous pouvez consulter RFC2045~RFC2049, qui contient des spécifications détaillées pour MIME. Base64 nécessite de convertir tous les trois octets de 8 bits en quatre octets de 6 bits (3*8 = 4*6 = 24), puis d'ajouter deux 0 de poids fort au 6 bits pour former quatre octets de 8 bits, c'est-à-dire que la chaîne convertie sera théoriquement 1/3 plus long que l'original

Fonctions PHP : base64_encode() et base64_decode()

Principe d'encodage et de décodage base64

L'encodage Base64 convertit en fait 3 octets de 8 bits en 4 octets de 6 bits, (3*8 = 4*6 = 24) Ces 4 octets de six bits sont en réalité toujours 8 bits, mais deux bits supérieurs sont mis à 0. Lorsque seulement 6 bits d'un octet sont valides, son l'espace de valeurs va de 0 à 2 à la puissance 6 moins 1, soit 63, c'est-à-dire que l'espace de valeurs de chaque codage du codage Base64 converti est (0 ~ 63).

En fait, il y a beaucoup de caractères invisibles dans les codes ASCII entre 0 et 63, donc un autre mappage devrait être fait. La table de mappage est

'A' ~ 'Z' ? ~ 25)

'a' ~ 'z' ? ASCII (26 ~ 51)

'0' ~ '9' ? ' ? ASCII (62)

'/' ? ASCII (63)

De cette façon, 3 octets de 8 bits peuvent être convertis en 4 caractères visibles.

La méthode de fractionnement d'octets spécifique est : (image (le dessin n'est pas bon, comprenez l'esprit :-))

aaaaaaabb ccccdddd eeffffff //abcdef est en fait 1 ou 0, pour visualiser Si c'est clair, utilisez plutôt abcdef

~~~~~~~~ ~~~~~~~~ ~~~~~~~~

Octet 1 Octet 2 Octet 3

　　|| Les deux bits sont à 0.

Lorsqu'il est divisé de cette manière, le nombre d'octets dans le texte original doit être un multiple de 3. Lorsque cette condition ne peut pas être remplie, utilisez tous les octets zéro

pour compenser. Utilisez plutôt le signe = pour l'encodage Base64 lors de la conversion, c'est pourquoi certains encodages Base64 se terminent par un ou deux signes égaux

, mais il y a au plus deux signes égaux, car : si F(origine) représente le nombre d'octets du texte original, F(remain) représente

pour représenter le reste, alors

F(remain) = F(origin) MOD 3 est établi.

Donc les valeurs possibles de F(remain) sont 0,1,2

Si n = [F(origine) – F(remain)] / 3
<.>Lorsque F(remain) = 0, il est converti en codage Base64 de 4*n octets.

Lorsque F(remain) = 1, puisqu'un octet de texte original peut être divisé en deux octets codés en Base64, afin de

laisser l'encodage Base64 être un multiple de 4, donc il devrait Ajouter 2 signes égaux.

Lorsque F(remain) = 2, puisque les deux octets du texte original peuvent être divisés en trois octets codés en Base64, de la même manière,

doit être rempli avec un signe égal.

Il y aura 0 à 2 signes égal à la fin de la chaîne encodée en base64. Ces signes égal ne sont pas nécessaires au décodage, ils peuvent donc être supprimés.
Dans les listes de paramètres réseau GET et POST, ' " ne peut pas être transmis normalement, vous pouvez le remplacer par '|'
De cette façon, la chaîne encodée en base64 n'aura que '| et '/', donc après La chaîne codée en base64 ainsi traitée peut être transmise comme valeur de paramètre dans la liste des paramètres

======================= ====== ============================================= ==
Ce qui suit C'est une implémentation écrite par des étrangers :
package com.meterware.httpunit





Pour plus d'articles liés au JAVA; implémentation de base64_encode et base64_decode, veuillez faire attention au site Web PHP chinois !

/******************************************************************************************************************** <br>* $Id: Base64.java,v 1.4 2002/12/24 15:17:17 russgold Exp $ <br>* <br>* Copyright (c) 2000-2002 by Russell Gold <br>* <br>* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated <br>* documentation files (the "Software "), to deal in the Software without restriction, including without limitation <br>* the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and <br>* to permit persons to whom the Software is furnished to do so, subject to the following conditions: <br>* <br>* The above copyright notice and this permission notice shall be included in all copies or substantial portions <br>* of the Software. <br>* <br>* THE SOFTWARE IS PROVIDED "AS IS ", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO <br>* THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE <br>* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF <br>* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER <br>* DEALINGS IN THE SOFTWARE. <br>* <br>*******************************************************************************************************************/ <br><br>/** <br>* A utility class to convert to and from base 64 encoding. <br>* <br>* @author <a href= "mailto:russgold@httpunit.org "> Russell Gold </a> <br>**/ <br> 
public class Base64 {       
    final static String encodingChar = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ "; /** 
  * Returns the base 64 encoded equivalent of a supplied string. 
  * @param source the string to encode 
  */
 public static String encode( String source ) { 
  char[] sourceBytes = getPaddedBytes( source ); 
  int numGroups = (sourceBytes.length + 2) / 3; 
  char[] targetBytes = new char[4]; 
  char[] target = new char[ 4 * numGroups ]; 
 
  for (int group = 0; group < numGroups; group++) { 
   convert3To4( sourceBytes, group*3, targetBytes ); 
   for (int i = 0; i < targetBytes.length; i++) { 
    target[ i + 4*group ] = encodingChar.charAt( targetBytes[i] ); 
   } 
  } 
 
  int numPadBytes = sourceBytes.length - source.length(); 
 
  for (int i = target.length-numPadBytes; i < target.length; i++) target[i] = &#39;= &#39;; 
  return new String( target ); 
 } 
 
 
 private static char[] getPaddedBytes( String source ) { 
  char[] converted = source.toCharArray(); 
  int requiredLength = 3 * ((converted.length+2) /3); 
  char[] result = new char[ requiredLength ]; 
  System.arraycopy( converted, 0, result, 0, converted.length ); 
  return result; 
 } 
 
 
 private static void convert3To4( char[] source, int sourceIndex, char[] target ) { 
  target[0] = (char) ( source[ sourceIndex ] > > > 2); 
  target[1] = (char) (((source[ sourceIndex ] & 0x03) < < 4) | (source[ sourceIndex+1 ] > > > 4)); 
  target[2] = (char) (((source[ sourceIndex+1 ] & 0x0f) < < 2) | (source[ sourceIndex+2 ] > > > 6)); 
  target[3] = (char) ( source[ sourceIndex+2 ] & 0x3f); 
 } 
 
 
 /** 
  * Returns the plaintext equivalent of a base 64-encoded string. 
  * @param source a base 64 string (which must have a multiple of 4 characters) 
  */
 public static String decode( String source ) { 
  if (source.length()%4 != 0) throw new RuntimeException( "valid Base64 codes have a multiple of 4 characters " ); 
  int numGroups = source.length() / 4; 
  int numExtraBytes = source.endsWith( "== " ) ? 2 : (source.endsWith( "= " ) ? 1 : 0); 
  byte[] targetBytes = new byte[ 3*numGroups ]; 
  byte[] sourceBytes = new byte[4]; 
  for (int group = 0; group < numGroups; group++) { 
   for (int i = 0; i < sourceBytes.length; i++) { 
    sourceBytes[i] = (byte) Math.max( 0, encodingChar.indexOf( source.charAt( 4*group+i ) ) ); 
   } 
   convert4To3( sourceBytes, targetBytes, group*3 ); 
  } 
  return new String( targetBytes, 0, targetBytes.length - numExtraBytes ); 
 } 
 
 
 private static void convert4To3( byte[] source, byte[] target, int targetIndex ) { 
  target[ targetIndex ] = (byte) (( source[0] < < 2) | (source[1] > > > 4)); 
  target[ targetIndex+1 ] = (byte) (((source[1] & 0x0f) < < 4) | (source[2] > > > 2)); 
  target[ targetIndex+2 ] = (byte) (((source[2] & 0x03) < < 6) | (source[3])); 
 } 
 
}