php - example - hash base64

Cómo comprobar si una cadena es base64 válida en PHP

Question

Tengo una cadena y quiero probar usando PHP si es una base64 válida codificada o no.

Answer 1

Creo que la única manera de hacerlo es hacer un base64_decode() con el parámetro $strict establecido en true , y ver si devuelve false .

Answer 2

Esta es una pregunta realmente antigua, pero encontré que el siguiente enfoque es prácticamente a prueba de balas. También tiene en cuenta esas cadenas extrañas con caracteres no válidos que causarían una excepción al validar.

    public static function isBase64Encoded($str) 
{
    try
    {
        $decoded = base64_decode($str, true);

        if ( base64_encode($decoded) === $str ) {
            return true;
        }
        else {
            return false;
        }
    }
    catch(Exception $e)
    {
        // If exception is caught, then it is not a base64 encoded string
        return false;
    }

}

Obtuve la idea de esta página y la adapté a PHP.

Answer 3

Este código debería funcionar, ya que la función de decodificación devuelve FALSE si la cadena no es válida:

if (base64_decode($mystring, true)) {
    // is valid
} else {
    // not valid
}

Puede leer más sobre la función base64_decode en la documentación .

Answer 4

Estoy usando este enfoque. Espera que los últimos 2 caracteres sean ==

substr($buff, -2, 1) == ''='' && substr($buff, -1, 1) == ''='')

Actualización: terminé haciendo otro control si el anterior falla base64_decode ($ buff, true)

Answer 5

Intenté lo siguiente:

• base64 decodifica la cadena con el parámetro estricto establecido en verdadero.
• base64 codifica el resultado del paso anterior. si el resultado no es el mismo que el de la cadena original, la cadena original no está codificada en base64
• si el resultado es el mismo que el de la cadena anterior, entonces verifique si la cadena descodificada contiene caracteres imprimibles. ctype_print función php ctype_print para verificar si hay caracteres no imprimibles. La función devuelve falso si la cadena de entrada contiene uno o más caracteres no imprimibles.

El siguiente código implementa los pasos anteriores:

public function IsBase64($data) {
    $decoded_data = base64_decode($data, true);
    $encoded_data = base64_encode($decoded_data);
    if ($encoded_data != $data) return false;
    else if (!ctype_print($decoded_data)) return false;

    return true;
}

El código anterior puede devolver resultados inesperados. Por ejemplo, para la cadena "json" devolverá falso. "json" puede ser una cadena codificada base64 válida ya que el número de caracteres que tiene es un múltiplo de 4 y todos los caracteres están en el rango permitido para las cadenas codificadas en base64. Parece que debemos conocer el rango de caracteres permitidos de la cadena original y luego verificar si los datos decodificados tienen esos caracteres.

Answer 6

Me doy cuenta de que este es un tema antiguo, pero usar el parámetro estricto no necesariamente ayudará.

Ejecutar base64_decode en una cadena como "No estoy codificado en base 64" no devolverá falso.

Sin embargo, si intenta decodificar la cadena con estricta y recodificarla con base64_encode, puede comparar el resultado con los datos originales para determinar si es un valor válido de bas64 codificado:

if ( base64_encode(base64_decode($data, true)) === $data){
    echo ''$data is valid'';
} else {
    echo ''$data is NOT valid'';
}

Answer 7

Puede enviar la cadena a través de base64_decode (con $ strict establecido en TRUE), se devolverá FALSE si la entrada no es válida.

También puede usar expresiones fi regulares para ver si la cadena contiene caracteres fuera del alfabeto base64 y verificar si contiene la cantidad correcta de relleno al final ( = caracteres). Pero solo usar base64_decode es mucho más fácil, y no debería existir el riesgo de que una cadena malformada cause daños.

Answer 8

Puedes usar esta función:

 function is_base64($s)
{
      return (bool) preg_match(''/^[a-zA-Z0-9///r/n+]*={0,2}$/'', $s);
}

Answer 9

Sé que recurro a una pregunta muy antigua y probé todos los métodos propuestos; finalmente termino con esta expresión regular que cubre casi todos mis casos:

$decoded = base64_decode($string, true);
if (0 < preg_match(''/((?![[:graph:]])(?!/s)(?!/p{L}))./'', $decoded, $matched)) return false;

básicamente, compruebo cada carácter que no es imprimible (: gráfico :) no es un espacio o pestaña (s) y no es una letra Unicode (todo acento ex: èéùìà etc.)

todavía obtengo un falso positivo con este carácter: £ § ° pero nunca los uso en una cadena y para mí está perfectamente bien invalidarlos. Agrego este control con la función propuesta por @merlucin

entonces el resultado:

function is_base64($s)
{
  // Check if there are valid base64 characters
  if (!preg_match(''/^[a-zA-Z0-9///r/n+]*={0,2}$/'', $s)) return false;

  // Decode the string in strict mode and check the results
  $decoded = base64_decode($s, true);
  if(false === $decoded) return false;

  // if string returned contains not printable chars
  if (0 < preg_match(''/((?![[:graph:]])(?!/s)(?!/p{L}))./'', $decoded, $matched)) return false;

  // Encode the string again
  if(base64_encode($decoded) != $s) return false;

  return true;
}

Answer 10

Si los datos no son válidos base64, entonces la función base64_decode ($ string, true) devolverá FALSE.

Answer 11

Solo para cadenas, puede usar esta función, que verifica varias propiedades de base64 antes de devolver verdadero:

function is_base64($s){
    // Check if there are valid base64 characters
    if (!preg_match(''/^[a-zA-Z0-9///r/n+]*={0,2}$/'', $s)) return false;

    // Decode the string in strict mode and check the results
    $decoded = base64_decode($s, true);
    if(false === $decoded) return false;

    // Encode the string again
    if(base64_encode($decoded) != $s) return false;

    return true;
}

Answer 12

Tema anterior, pero encontré esta función y está funcionando:

function checkBase64Encoded($encodedString) {
$length = strlen($encodedString);

// Check every character.
for ($i = 0; $i < $length; ++$i) {
$c = $encodedString[$i];
if (
($c < ''0'' || $c > ''9'')
&& ($c < ''a'' || $c > ''z'')
&& ($c < ''A'' || $c > ''Z'')
&& ($c != ''+'')
&& ($c != ''/'')
&& ($c != ''='')
) {
// Bad character found.
return false;
}
}
// Only good characters found.
return true;
}

Answer 13

base64_decode () debería devolver false si sus datos codificados en base64 no son válidos.