Base64 es uno de los métodos de codificación más comunes en la red para transmitir el código de byte de 8 bits. Puede consultar RFC2045 ~ RFC2049, que contiene especificaciones MIME detalladas. Base64 requiere convertir cada tres bytes de 8 bits en cuatro bytes de 6 bits (3*8 = 4*6 = 24), y luego agregar dos 0 a 6 bits altos para formar cuatro bytes de 8 bits. En otras palabras, la cadena convertida será teóricamente 1/3 más larga que la original.
Funciones php: base64_encode () y base64_decode ()
Base64 Codificación, principio de decodificación
La codificación base64 en realidad convierte 3 bytes de 8 bits en 4 bytes de 6 bits, (3*8 = 4*6 = 24) Estos 4 bytes de seis bits en realidad siguen siendo 8 bits, pero los dos bits más altos se establecen en 0. Cuando solo 6 bits de un byte son válidos, su espacio de valor es 0 a 2 mínimo 1 a la 63 potencia de 63, es decir, el espacio de valor de cada código de la base 64 es un código convertado. (0 ~ 63).
De hecho, hay muchos caracteres invisibles en el código ASCII entre 0 y 63, por lo que se debe hacer otro mapeo, y la tabla de mapeo es
'A' ~ 'Z'? ASCII (0 ~ 25)
'A' ~ 'Z'? ASCII (26 ~ 51)
'0' ~ '9'? ASCII (52 ~ 61)
''? ASCII (62)
'/'? ASCII (63)
Esto convertirá 3 bytes de 8 bits en 4 caracteres visibles.
El método específico de división de bytes es: (figura (dibujada mal, comprende el espíritu :-))
aaaaaabb cccdddd eeffffff // abcdef es en realidad 1 o 0. Para ver claramente, use ABCDEF en su lugar
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Byte 1 byte 2 byte 3
||
//
00aaaaaaa 00bbcccc 00dddee 00ffffff
NOTA: Los tres bits de tres bytes anteriores son el texto original, los siguientes cuatro bytes son la codificación Base64, y los dos primeros bits son 0.
Al dividir de esta manera, el número de bytes en el texto original debe ser un múltiplo de 3. Cuando esta condición no se puede cumplir, use todos los bytes cero
El complemento, al convertir, la codificación base64 se reemplaza por = signo, por lo que algunas codificaciones Base64 terminan con uno o dos signos iguales.
La razón del paquete, pero hay como máximo dos signos iguales, porque: si F (origen) representa el número de bytes en el texto original, f (permanecer) se usa a
RESTACIÓN DE TABLA, entonces
F (permanecer) = F (origen) Mod 3 está establecido.
Por lo tanto, los valores posibles de F (permanecer) son 0, 1, 2.
Si n = [f (origen) f (permanecer)] / 3
Cuando f (permanecer) = 0, se convierte a 4*n bytes base64 codificación.
Cuando f (permanecer) = 1, ya que un byte literal se puede dividir en dos bytes codificados en Base64, para que
Deje que Base64 codifique sea un múltiplo de 4, por lo que debe complementarse con 2 signos iguales.
Cuando f (permanecer) = 2, ya que los dos bytes de texto originales se pueden dividir en 3 bytes codificados en Base64, de manera similar,
Se debe agregar un signo igual.
Base64 Habrá 0 a 2 signos iguales al final de la cadena codificada. Estos signos iguales no son necesarios para decodificar, por lo que se pueden eliminar.
Cuando se enumeran las listas de parámetros de obtención de redes y publicar, '+' no se puede transmitir normalmente, por lo que puede reemplazarlo con '|'
De esta manera, las cadenas codificadas por Base64 solo tienen '|' y '/', por lo que las cadenas codificadas en Base64 pueden transferirse como listas de parámetros con valores de parámetros
================================================================================================================================================================================= ¡
La siguiente es una implementación escrita por extranjeros:
paquete com.meterware.httpunit;
/****************************************************************************************************************************************************--
* $ ID: Base64.java, V 1.4 2002/12/24 15:17:17 RussGold Exp $
*
* Copyright (c) 2000-2002 por Russell Gold
*
* Por la presente, se otorga el permiso, de forma gratuita, a cualquier persona que obtenga una copia de este software y asociado
* Archivos de documentación (el "Software"), para tratar el software sin restricciones, incluidos sin limitación
* Los derechos para usar, copiar, modificar, fusionar, publicar, distribuir, sublicense y/o vender copias del software, y
* Para permitir que las personas a quienes se proporcione el software lo haga, sujeto a las siguientes condiciones:
*
* El aviso de derechos de autor anterior y este aviso de permiso se incluirán en todas las copias o porciones sustanciales
* del software.
*
* El software se proporciona "tal cual", sin garantía de ningún tipo, expresa o implícita, que incluye, entre otros,
* Las garantías de comerciabilidad, idoneidad para un propósito particular y no infracción. En ningún caso el
* Los autores o los titulares de derechos de autor deben ser responsables de cualquier reclamo, daños u otra responsabilidad, ya sea en una acción de
* Contrato, agravio o de otra manera, derivado de, de o en relación con el software o el uso u otro
* Tratos en el software.
*
**********************************************************************************************************************************************************************************--
/**
* Una clase de utilidad para convertir hacia y desde la base 64 codificación.
*
* @author <a href = "mailto: [email protected]"> Russell Gold </a>
**/
clase pública base64 {cadena estática final codingchar = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/"; /*** Devuelve el equivalente codificado de base 64 de una cadena suministrada. * @param fuente La cadena para codificar */ public static String code (fuente de cadena) {char [] SourceBytes = getPaddedBytes (fuente); int numGroups = (SourceBytes.length + 2) / 3; char [] TargetBytes = new Char [4]; char [] Target = new Char [4 * numGrups]; for (int group = 0; grupo <numGroups; grupo ++) {convert3To4 (fuenteByTes, grupo*3, TargetBytes); for (int i = 0; i <TargetBytes.length; i ++) {Target [i+4*Group] = EncodingChar.Charat (TargetBytes [i]); }} int numpadbytes = SourceBytes.Length - Source.length (); para (int i = target.length-numpadbytes; i <target.length; i ++) Target [i] = '='; devolver nueva cadena (objetivo); } private static char [] getPaddedBytes (fuente de cadena) {char [] convertida = fuente.toCarArray (); int requiredLength = 3 * ((convertido.length+2) /3); char [] resultado = nuevo char [requirirlength]; System.ArrayCopy (convertido, 0, resultado, 0, convertido.length); resultado de retorno; } private static void convert3To4 (char [] fuente, int SourceIndex, char [] target) {target [0] = (char) (fuente [fuente]>>>> 2); Target [1] = (char) (((fuente [SourceIndex] y 0x03) <<4) | (fuente [fuenteindex+1] >>> 4)); Target [2] = (char) (((fuente [SourceIndex+1] y 0x0f) <<2) | (fuente [SourceIndex+2] >> 6)); objetivo [3] = (char) (fuente [fuenteindex+2] y 0x3f); } /*** Devuelve el equivalente de texto sin formato de una cadena codificada de 64. * @param fuente Una cadena base 64 (que debe tener un múltiplo de 4 caracteres) */ public static String decode (fuente de cadena) {if (fuente.length ()%4! = 0) tirar nueva runtimeException ("Los códigos de base 64 válidos tienen un múltiplo de 4 caracteres"); int numGroups = Source.length () / 4; int numExtrabytes = fuente.endswith ("==")? 2: (fuente.endswith ("=")? 1: 0); byte [] TargetBytes = new Byte [3*numgrups]; byte [] SourceBytes = nuevo byte [4]; for (int group = 0; grupo <numGrups; group ++) {for (int i = 0; i <sourceBytes.length; i ++) {sourceBytes [i] = (byte) math.max (0, codingchar.indexof (fuente.charat (4*grupo+i))); } Convert4TO3 (SourceBytes, TargetBytes, Grupo*3); } return New String (TargetBytes, 0, TargetBytes.Length - NumExTrabytes); } private static void convert4to3 (byte [] fuente, byte [] target, int targetIndex) {target [targetIndex] = (byte) ((fuente [0] <<2) | (fuente [1] >>> 4)); Target [TargetIndex+1] = (byte) (((fuente [1] y 0x0f) <<4) | (fuente [2] >>> 2)); Target [TargetIndex+2] = (Byte) (((fuente [2] y 0x03) <<6) | (fuente [3])); }}